<html>
 <head>
  <meta charset="utf-8"/>
  <meta content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" name="viewport"/>
  <title>
   技术揭秘！Peacock大规模主题模型及其在腾讯业务中的应用  | 数螺 | NAUT IDEA
  </title>
  <link href="http://cdn.bootcss.com/bootstrap/3.3.6/css/bootstrap-theme.min.css" rel="stylesheet"/>
  <link href="http://cdn.bootcss.com/bootstrap/3.3.6/css/bootstrap.min.css" rel="stylesheet"/>
  <style type="text/css">
   #xmain img {
                  max-width: 100%;
                  display: block;
                  margin-top: 10px;
                  margin-bottom: 10px;
                }

                #xmain p {
                    line-height:150%;
                    font-size: 16px;
                    margin-top: 20px;
                }

                #xmain h2 {
                    font-size: 24px;
                }

                #xmain h3 {
                    font-size: 20px;
                }

                #xmain h4 {
                    font-size: 18px;
                }


                .header {
	           background-color: #0099ff;
	           color: #ffffff;
	           margin-bottom: 20px;
	        }

	        .header p {
                  margin: 0px;
                  padding: 10px 0;
                  display: inline-block;  
                  vertical-align: middle;
                  font-size: 16px;
               }

               .header a {
                 color: white;
               }

              .header img {
                 height: 25px;
              }
  </style>
  <script src="http://cdn.bootcss.com/jquery/3.0.0/jquery.min.js">
  </script>
  <script src="http://nautstatic-10007657.file.myqcloud.com/static/css/readability.min.js" type="text/javascript">
  </script>
  <script type="text/javascript">
   $(document).ready(function() {
                 var loc = document.location;
                 var uri = {
                  spec: "http://dataunion.org/11407.html",
                  host: "http://dataunion.org",
                  prePath: "http://dataunion.org",
                  scheme: "http",
                  pathBase: "http://dataunion.org/"
                 };
    
                 var documentClone = document.cloneNode(true);
                 var article = new Readability(uri, documentClone).parse();
     
                 document.getElementById("xmain").innerHTML = article.content;
                });
  </script>
  <!-- 1466454712: Accept with keywords: (title(0.142857142857):社区,模型,主题,业务,数盟,技术,腾讯, topn(0.5):概率,数盟,任务,过程,示例,语料,模型,并行,文档,相关性,计算,物品,点击率,数据,向量,效果,矩阵,语义,用户,算法,腾讯,训练器,海量,主题,系统,分解,广告,聚类,文本,兴趣).-->
 </head>
 <body onload="">
  <div class="header">
   <div class="container">
    <div class="row">
     <div class="col-xs-6 col-sm-6 text-left">
      <a href="/databee">
       <img src="http://nautidea-10007657.cos.myqcloud.com/logo_white.png"/>
      </a>
      <a href="/databee">
       <p>
        数螺
       </p>
      </a>
     </div>
     <div class="hidden-xs col-sm-6 text-right">
      <p>
       致力于数据科学的推广和知识传播
      </p>
     </div>
    </div>
   </div>
  </div>
  <div class="container text-center">
   <h1>
    技术揭秘！Peacock大规模主题模型及其在腾讯业务中的应用
   </h1>
  </div>
  <div class="container" id="xmain">
   ﻿﻿
   <title>
    技术揭秘！Peacock大规模主题模型及其在腾讯业务中的应用 | 数盟社区
   </title>
   <!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[32,77] -->
   <!-- /all in one seo pack -->
   <!--
<div align="center">
<a href="http://strata.oreilly.com.cn/hadoop-big-data-cn?cmp=mp-data-confreg-home-stcn16_dataunion_pc" target="_blank"><img src="http://dataunion.org/wp-content/uploads/2016/05/stratabj.jpg"/ ></a>
</div>
-->
   <header id="header-web">
    <div class="header-main">
     <hgroup class="logo">
      <h1>
       <a href="http://dataunion.org/" rel="home" title="数盟社区">
        <img src="http://dataunion.org/wp-content/themes/yzipi/images/logo.png"/>
       </a>
      </h1>
     </hgroup>
     <!--logo-->
     <nav class="header-nav">
      <ul class="menu" id="menu-%e4%b8%bb%e8%8f%9c%e5%8d%95">
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-71" id="menu-item-71">
        <a href="http://dataunion.org/category/events" title="events">
         活动
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-22457" id="menu-item-22457">
          <a href="http://dataunion.org/2016timeline">
           2016档期
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-22459" id="menu-item-22459">
          <a href="http://dataunion.org/category/parterc">
           合作会议
          </a>
         </li>
        </ul>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category current-post-ancestor menu-item-has-children menu-item-20869" id="menu-item-20869">
        <a href="http://dataunion.org/category/tech" title="articles">
         文章
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-20867" id="menu-item-20867">
          <a href="http://dataunion.org/category/tech/base" title="base">
           基础架构
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category current-post-ancestor current-menu-parent current-post-parent menu-item-3302" id="menu-item-3302">
          <a href="http://dataunion.org/category/tech/ai" title="ai">
           人工智能
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-3303" id="menu-item-3303">
          <a href="http://dataunion.org/category/tech/analysis" title="analysis">
           数据分析
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-21920" id="menu-item-21920">
          <a href="http://dataunion.org/category/tech/dm">
           数据挖掘
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-3314" id="menu-item-3314">
          <a href="http://dataunion.org/category/tech/viz" title="viz">
           可视化
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-3305" id="menu-item-3305">
          <a href="http://dataunion.org/category/tech/devl" title="devl">
           编程语言
          </a>
         </li>
        </ul>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-20876" id="menu-item-20876">
        <a href="http://dataunion.org/category/industry">
         行业
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-16328" id="menu-item-16328">
          <a href="http://dataunion.org/category/industry/case" title="case">
           行业应用
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-2112" id="menu-item-2112">
          <a href="http://dataunion.org/category/industry/demo" title="demo">
           Demo展示
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-21562" id="menu-item-21562">
          <a href="http://dataunion.org/category/industry/news">
           行业资讯
          </a>
         </li>
        </ul>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-311" id="menu-item-311">
        <a href="http://dataunion.org/category/sources" title="sources">
         资源
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-20870" id="menu-item-20870">
        <a href="http://dataunion.org/category/books" title="book">
         图书
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-21363" id="menu-item-21363">
        <a href="http://dataunion.org/category/training">
         课程
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-21853" id="menu-item-21853">
        <a href="http://dataunion.org/category/jobs">
         职位
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-22050" id="menu-item-22050">
          <a href="http://dataunion.org/category/career">
           职业规划
          </a>
         </li>
        </ul>
       </li>
      </ul>
     </nav>
     <!--header-nav-->
    </div>
   </header>
   <!--header-web-->
   <div id="main">
    <div id="soutab">
     <form action="http://dataunion.org/" class="search" method="get">
     </form>
    </div>
    <div id="container">
     <nav id="mbx">
      当前位置：
      <a href="http://dataunion.org">
       首页
      </a>
      &gt;
      <a href="http://dataunion.org/category/tech">
       文章
      </a>
      &gt;
      <a href="http://dataunion.org/category/tech/ai">
       人工智能
      </a>
      &gt;  正文
     </nav>
     <!--mbx-->
     <article class="content">
      <header align="centre" class="contenttitle">
       <div class="mscc">
        <h1 class="mscctitle">
         <a href="http://dataunion.org/11407.html">
          技术揭秘！Peacock大规模主题模型及其在腾讯业务中的应用
         </a>
        </h1>
        <address class="msccaddress ">
         <em>
          2,651 次阅读 -
         </em>
         <a href="http://dataunion.org/category/tech/ai" rel="category tag">
          人工智能
         </a>
        </address>
       </div>
      </header>
      <div class="content-text">
       <h3>
        作者：赵学敏 王莉峰 王流斌 孙振龙 严浩 靳志辉 王益
       </h3>
       <h3>
        摘要
       </h3>
       <p>
        如果用户最近搜索了“红酒木瓜汤”，那么应该展示什么样的广告呢？从字面上理解，可能应该返回酒水或者水果类广告。可是你知道吗？“红酒木瓜汤”其实是一个民间丰胸秘方。如果机器能理解这个隐含语义，就能展示丰胸或者美容广告——这样点击率一定很高。在广告、搜索和推荐中，最重要的问题之一就是理解用户兴趣以及页面、广告、商品等的隐含语义。
       </p>
       <p>
        让机器能自动学习和理解人类语言中近百万种语义，以及从海量用户行为数据中归纳用户兴趣，是一个已经持续了20年的研究方向，称为主题建模（Latent Topic Modeling）。目前业界的各种系统中最为突出的是Google Rephil，在Google AdSense广告系统中发挥了重要作用。
       </p>
       <p>
        追随Google的脚步，腾讯SNG效果广告平台部（广点通）的同学们成功的研发了Peacock大规模主题模型机器学习系统，通过并行计算可以高效地对10亿x1亿级别的大规模矩阵进行分解，从而从海量样本数据中学习10万到100万量级的隐含语义。我们把Peacock系统应用到了腾讯业务中，包括文本语义理解、QQ群的推荐、用户商业兴趣挖掘、相似用户扩展、广告点击率转化率预估等，均取得了不错的效果。
       </p>
       <h3>
        一、为什么我们要开发大规模主题模型训练系统Peacock？
       </h3>
       <h4>
        1.1 短文本相关性
       </h4>
       <p>
        在自然语言处理和信息检索中，我们常常会遇到如下问题：给定查询词，计算查询词和文档之间的相关性。比如表1给出了2个具体例子，此时我们需要计算短文本之间的相关性。常用的计算方法就是不考虑词的相对顺序，使用BOW（Bag-Of-Words）模型把文档表示为词向量，然后计算文本之间的相似度。如果直接采用文档中词的TF-IDF构建文档特征向量，通过计算查询词特征向量和文档特征向量的余弦夹角，我们会发现Q1与D1、D2都相关，而Q2与D1、D2都不相关。显然，这与人对自然语言的理解并不相符：Q1和D2比较相关，都关于“苹果”这种水果；而Q2和D1比较相关，都关于“苹果”公司。
       </p>
       <div>
        <strong>
         表1 短文本相关性
        </strong>
        <br/>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-t1.png"/>
       </div>
       <div>
       </div>
       <p>
        之所以会出现这种差异，是因为上述文档特征向量构建方法没有“理解”文档的具体语义信息，单纯的将文档中的词表示为一个ID而已。通过主题模型，文档可以表示为一个隐含语义空间上的概率分布向量（主题向量），文档主题向量之间的余弦夹角就可以一定程度上反映文档间的语义相似度了。
       </p>
       <h4>
        1.2 推荐系统
       </h4>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f1.jpg"/>
        <br/>
        <strong>
         图1 用户-物品矩阵
        </strong>
       </div>
       <div>
       </div>
       <p>
        主题模型的另一个主要应用场景是推荐系统。不管是电商网站的商品推荐，还是各大视频网站的视频推荐等，都可以简化为如下问题：给定用户-物品矩阵（图1，矩阵中用户
        <em>
         u
        </em>
        和物品
        <em>
         i
        </em>
        对应的值表示
        <em>
         u
        </em>
        对
        <em>
         i
        </em>
        的偏好，根据用户行为数据，矩阵会得到部分“初始”值），如何“填满”矩阵中没有值的部分。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f2.jpg"/>
       </div>
       <div>
        <strong>
         图2 物品聚类
        </strong>
       </div>
       <div>
       </div>
       <p>
        在各种眼花缭乱的推荐算法中，直接利用用户-物品矩阵进行推荐是最有效的方式（没有长年的用户、物品内容分析技术积累也一样可以快速做出效果），而这其中的两类主要算法都与主题模型有关系：
       </p>
       <ul>
        <li>
         协同过滤
         <sup>
          [1]
         </sup>
         。以基于用户的协同过滤为例，就是要向用户推荐与之相似的用户喜欢的物品，包含两个主要步骤：计算用户相似度和向用户推荐与自己最相似的用户喜欢的物品，难点在于计算用户相似度。如果不引入外部数据，最简单的计算用户
         <em>
          u
         </em>
         和
         <em>
          v
         </em>
         相似度的方法可以直接利用用户-物品矩阵的
         <em>
          u
         </em>
         行和
         <em>
          v
         </em>
         行，比如计算它们的余弦夹角。然而，真实的互联网数据中，用户-物品矩阵通常都非常稀疏，直接计算不能得到准确的结果。此时，常见的做法是对用户（或物品）进行聚类或者将矩阵投影到更低维的隐空间（图2、3），在隐空间计算用户相似度可以更加准确。主题模型可以用来将用户-物品矩阵投影到隐空间。
        </li>
        <li>
         隐含语义模型 (Latent Factor Model, LFM)
         <sup>
          [2]
         </sup>
         。该类方法本质上和主题模型是一致的，直观的理解是将用户-物品矩阵分解为用户-隐含语义（主题）矩阵和隐含语义（主题）-物品矩阵（图3），通过更低维度的上述两个矩阵，来重构原始用户-物品矩阵，重构得到的矩阵将不再稀疏，可以直接用于推荐。具体例子可以参看“QQ群推荐”应用。
        </li>
       </ul>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f3.jpg"/>
        <br/>
        <strong>
         图3 用户-物品矩阵分解
        </strong>
       </div>
       <div>
       </div>
       <p>
        实际上，从以上的讨论中我们容易发现，当使用BOW模型处理文本，把文档数据表示成文档-词（Doc-Word）矩阵的时候，其表示结构和用户-物品（User-Item）矩阵结构是完全一致的。因此这两类数据可以使用同样的算法进行处理。使用隐含主题模型处理文档-词矩阵的时候，可以理解为把词聚类为主题，并计算各个文档和词聚类之间的权重。类似地，处理用户-物品矩阵的时候，可以理解为把物品聚类为主题，然后计算每个用户和各个聚类之间的权重。图2是这个过程的一个形象描述，而这个过程如图3所示，可以理解为把原始矩阵分解为两个较小的矩阵：左下的Topic-Item矩阵描述了物品聚类，每行一个主题（Topic）表示一个聚类；而右侧的User-Topic矩阵每一行为主题权重向量，表示每个用户和每个主题的紧密关系。
       </p>
       <h4>
        1.3 Peacock是什么？
       </h4>
       <p>
        从上面两个小节我们已经看到，主题模型在互联网产业中具有非常重要的应用。而Peacock系统着手开发时（2012年11月），一些开源以及学术界的主题模型训练系统
        <sup>
         [5,6,7,8]
        </sup>
        ，要么只能处理小规模的训练语料得到“小模型”，要么模型质量不佳。基于这种状况，我们设计并开发了Peacock系统（更多有关Peacock系统的设计哲学和开发进程，可以参考王益的博客
        <sup>
         [3]
        </sup>
        和图灵访谈文章
        <sup>
         [4]
        </sup>
        ）。Peacock是一个大规模主题模型训练系统，它既可以从数十亿的网络语料中学习出百万级别的隐含语义（主题），也可以对数十亿乘以几亿规模的矩阵进行“分解”。我们的工作总结成论文“Peacock: Learning Long-Tail Topic Features for Industrial Applications”发表在ACM Transaction on Intelligent System and Technology (2015)
        <sup>
         [15]
        </sup>
        。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f4.jpg"/>
        <br/>
        <strong>
         图4 Peacock文档语义推断系统Demo
        </strong>
       </div>
       <div>
       </div>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f5.png"/>
        <br/>
        <strong>
         图5 Peacock文档语义推断示例1：“苹果”
        </strong>
       </div>
       <div>
       </div>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f6.png"/>
        <br/>
        <strong>
         图6 Peacock文档语义推断示例2：“苹果 梨子”
        </strong>
       </div>
       <div>
       </div>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f7.png"/>
        <br/>
        <strong>
         图7 Peacock文档语义推断示例3：“苹果大尺度”
        </strong>
       </div>
       <div>
       </div>
       <p>
        下面我们分别给定一些具体的例子，让大家对Peacock有一些直观上的认识：
       </p>
       <ul>
        <li>
         自然语言处理的例子。图4给出了Peacock在线推断系统Demo的主要界面，手动输入文档以后，点击“submit”就可以看到Peacock对输入文档的理解。这个例子中，我们利用训练好的Peacock模型，在线推断给定的输入文档的主题分布P(topic|doc)。每一行打印出一个语义主题，并给出主题的权重。具体的主题由一组相关的词组成，每个词都有权重。而第二部分 P(word|doc) 则给出了和该文档相关的权重最高的词。在Demo的例子中，我们可以看到 Peacock 对“红酒木瓜汤”这个检索串最重要的语义理解是“丰胸、产品、减肥、木瓜、效果”，非常符合人的语义理解。图5、6、7演示了典型的多义词“苹果”在不同语境下Peacock对其的不同理解，可以看到“苹果”这个检索串在 Peacock 中被处理成了如下三种语义：“苹果公司及其产品”、“水果”、“范冰冰《苹果》电影”。而“苹果、梨子”主要语义被理解为“水果”，“苹果大尺度”的主要语义被理解为“范冰冰《苹果》电影”。可以看到Peacock可以比较准确的理解不同文档的具体含义，这将有助于我们完成一系列自然语言处理和信息检索的任务。
        </li>
        <li>
         用户-物品矩阵分解的例子。这个例子中，“用户”（相当于“文档”）为QQ，“物品”（相当于“词”）为这部分用户加入的QQ兴趣群（在数据预处理中，我们会将QQ群分为关系群、兴趣群等，兴趣群可以比较好的反映用户的兴趣）。取非常活跃的5亿用户和非常活跃的1亿QQ兴趣群，得到一个5亿x1亿的矩阵，使用Peacock分解该矩阵后获得Topic-Item矩阵（即主题-QQ群矩阵），图8、9、10分别给出了该矩阵中的三个主题（只显示权重最高的主要QQ群）。为了方便理解，同时将QQ群的描述信息显示在群ID之后。可以看到，Peacock学习得到的主题含义比较明确，一定程度上可以反映出Peacock在处理用户-物品矩阵上的有效性。
        </li>
       </ul>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f8.jpg"/>
        <br/>
        <strong>
         图8 基于QQ-QQ群Peacock矩阵分解示例：炒股类主题
        </strong>
       </div>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f9.jpg"/>
        <br/>
        <strong>
         图9 基于QQ-QQ群Peacock矩阵分解示例：塔防三国游戏类主题
        </strong>
       </div>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f10.jpg"/>
        <br/>
        <strong>
         图10 基于QQ-QQ群Peacock矩阵分解示例：济南母婴类主题
        </strong>
       </div>
       <div>
       </div>
       <p>
        通过一些具体的例子直观的介绍了主题模型之后，接下来第二章将主要从算法的角度来回答“什么是主题模型”这个问题，第三章介绍对主题模型并行化的一些思考以及Peacock的具体做法，最后第四章介绍主题模型在腾讯业务中的具体应用。
       </p>
       <h3>
        二、什么是主题模型？
       </h3>
       <p>
        下面以文档建模为例，简单介绍一下主题模型。
       </p>
       <h4>
        2.1 主题模型的“三个过程”
       </h4>
       <p>
        主题模型一般包含了三个重要的过程：生成过程、训练过程以及在线推断。生成过程定义了模型的假设以及具体的物理含义，训练过程定义了怎样由训练数据学习得出模型，在线推断定义了怎样应用模型。下面分别进行简要介绍。
       </p>
       <p>
        一般来说，主题模型是一种生成模型（生成模型可以直观的理解为给定模型，可以生成训练样本）。给定模型，其生成过程如图11：
       </p>
       <ul>
        <li>
         模型有2个主题，主题1关于银行（主要的词为loan、bank、money等），主题2关于河流（主要的词为river、stream、bank等）。
        </li>
        <li>
         文档1内容100%关于主题1，主题向量为&lt;1.0, 0.0&gt;，文档中每一个词的生成过程如下：以100%的概率选择主题1，再从主题1中以一定的概率挑选词。
        </li>
        <li>
         文档2内容50%关于主题1，50%关于主题2，主题向量为&lt;0.5, 0.5&gt;，文档中每一个词的生成过程如下：以均等的概率选择主题1和2，再从选中的主题中以一定的概率挑选词。
        </li>
        <li>
         文档3内容100%关于主题2，主题向量为&lt;0.0, 1.0&gt;，文档中每一个词的生成过程如下：以100%的概率选择主题2，再从主题2中以一定的概率挑选词。
        </li>
       </ul>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f11.jpg"/>
        <br/>
        <strong>
         图11 主题模型的生成过程
         <sup>
          [9]
         </sup>
        </strong>
       </div>
       <div>
       </div>
       <p>
        现实的情况是我们没有模型，只有海量的互联网文档数据，此时我们希望有机器学习算法可以自动的从训练文档数据中归纳出主题模型（如图12），即得到每个主题在词表上的具体分布。通常来说，训练过程还会得到一个副产品——每篇训练文档的主题向量。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f12.jpg"/>
        <br/>
        <strong>
         图12 主题模型的训练过程
         <sup>
          [9]
         </sup>
        </strong>
       </div>
       <div>
       </div>
       <p>
        有了主题模型，给定新的文档，通过在线推断，我们就可以得到文档的主题向量（如图13）。图5、6、7给出了一些具体的例子。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f13.jpg"/>
        <br/>
        <strong>
         图13 主题模型的在线推断
        </strong>
       </div>
       <div>
       </div>
       <p>
        三个过程中，训练过程是难点，后文将进行重点介绍。
       </p>
       <h4>
        2.2 LDA模型及其训练算法
       </h4>
       <p>
        LDA（Latent Dirichlet Allocation）
        <sup>
         [10]
        </sup>
        作为一种重要的主题模型，自发表以来就引起了学术界和产业界的极大关注，相关论文层出不穷。LDA的训练算法也多种多样，下面以吉布斯采样
        <sup>
         [11,12]
        </sup>
        为例，进行简要介绍。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f14.jpg"/>
        <br/>
        <strong>
         图14 LDA训练过程
        </strong>
       </div>
       <div>
       </div>
       <p>
        跳过复杂的数学推导，基于吉布斯采样的LDA训练过程如图14所示（每个词用
        <em>
         w
        </em>
        表示，每个词对应的主题用
        <em>
         z
        </em>
        表示，图中节点
        <em>
         z
        </em>
        的不同颜色表示不同的主题）：
       </p>
       <ul>
        <li>
         Step1: 初始时，随机的给训练语料中的每一个词
         <em>
          w
         </em>
         赋值一个主题
         <em>
          z
         </em>
         ，并统计两个频率计数矩阵：Doc-Topic计数矩阵
         <span class="MathJax" id="MathJax-Element-1-Frame">
          <span class="math" id="MathJax-Span-1">
           <span class="mrow" id="MathJax-Span-2">
            <span class="msubsup" id="MathJax-Span-3">
             <span class="mi" id="MathJax-Span-4">
              N
             </span>
             <span class="texatom" id="MathJax-Span-5">
              <span class="mrow" id="MathJax-Span-6">
               <span class="mi" id="MathJax-Span-7">
                t
               </span>
               <span class="mi" id="MathJax-Span-8">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ，描述每个文档中的主题频率分布；Word-Topic计数矩阵
         <span class="MathJax" id="MathJax-Element-2-Frame">
          <span class="math" id="MathJax-Span-9">
           <span class="mrow" id="MathJax-Span-10">
            <span class="msubsup" id="MathJax-Span-11">
             <span class="mi" id="MathJax-Span-12">
              N
             </span>
             <span class="texatom" id="MathJax-Span-13">
              <span class="mrow" id="MathJax-Span-14">
               <span class="mi" id="MathJax-Span-15">
                w
               </span>
               <span class="mi" id="MathJax-Span-16">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ，表示每个主题下词的频率分布。如图15所示，两个矩阵分别对应于图中的边上的频率计数。
        </li>
        <li>
         Step2: 遍历训练语料，按照概率重新采样其中每一个词
         <em>
          w
         </em>
         对应的主题
         <em>
          z
         </em>
         ，同步更新
         <span class="MathJax" id="MathJax-Element-3-Frame">
          <span class="math" id="MathJax-Span-17">
           <span class="mrow" id="MathJax-Span-18">
            <span class="msubsup" id="MathJax-Span-19">
             <span class="mi" id="MathJax-Span-20">
              N
             </span>
             <span class="texatom" id="MathJax-Span-21">
              <span class="mrow" id="MathJax-Span-22">
               <span class="mi" id="MathJax-Span-23">
                w
               </span>
               <span class="mi" id="MathJax-Span-24">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         和
         <span class="MathJax" id="MathJax-Element-4-Frame">
          <span class="math" id="MathJax-Span-25">
           <span class="mrow" id="MathJax-Span-26">
            <span class="msubsup" id="MathJax-Span-27">
             <span class="mi" id="MathJax-Span-28">
              N
             </span>
             <span class="texatom" id="MathJax-Span-29">
              <span class="mrow" id="MathJax-Span-30">
               <span class="mi" id="MathJax-Span-31">
                t
               </span>
               <span class="mi" id="MathJax-Span-32">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         。
        </li>
        <li>
         Step3: 重复 step2，直到
         <span class="MathJax" id="MathJax-Element-5-Frame">
          <span class="math" id="MathJax-Span-33">
           <span class="mrow" id="MathJax-Span-34">
            <span class="msubsup" id="MathJax-Span-35">
             <span class="mi" id="MathJax-Span-36">
              N
             </span>
             <span class="texatom" id="MathJax-Span-37">
              <span class="mrow" id="MathJax-Span-38">
               <span class="mi" id="MathJax-Span-39">
                w
               </span>
               <span class="mi" id="MathJax-Span-40">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         收敛。
        </li>
       </ul>
       <p>
        Step2中重新采样词
        <em>
         w
        </em>
        对应主题
        <em>
         z
        </em>
        时，采样公式为
       </p>
       <div class="MathJax_Display">
        <span class="MathJax" id="MathJax-Element-6-Frame">
         <span class="math" id="MathJax-Span-41">
          <span class="mrow" id="MathJax-Span-42">
           <span class="mtable" id="MathJax-Span-43">
            <span class="mtd" id="MathJax-Span-47">
             <span class="mrow" id="MathJax-Span-48">
              <span class="mtable" id="MathJax-Span-49">
               <span class="mtd" id="MathJax-Span-50">
                <span class="mrow" id="MathJax-Span-51">
                 <span class="mi" id="MathJax-Span-52">
                  P
                 </span>
                 <span class="mo" id="MathJax-Span-53">
                  (
                 </span>
                 <span class="mi" id="MathJax-Span-54">
                  z
                 </span>
                 <span class="mo" id="MathJax-Span-55">
                  =
                 </span>
                 <span class="mi" id="MathJax-Span-56">
                  t
                 </span>
                 <span class="texatom" id="MathJax-Span-57">
                  <span class="mrow" id="MathJax-Span-58">
                   <span class="mo" id="MathJax-Span-59">
                    |
                   </span>
                  </span>
                 </span>
                 <span class="mi" id="MathJax-Span-60">
                  w
                 </span>
                 <span class="mo" id="MathJax-Span-61">
                  ,
                 </span>
                 <span class="mo" id="MathJax-Span-62">
                  ∗
                 </span>
                 <span class="mo" id="MathJax-Span-63">
                  )
                 </span>
                </span>
               </span>
               <span class="mtd" id="MathJax-Span-119">
                <span class="mrow" id="MathJax-Span-120">
                </span>
               </span>
               <span class="mtd" id="MathJax-Span-64">
                <span class="mrow" id="MathJax-Span-65">
                 <span class="mo" id="MathJax-Span-66">
                  =
                 </span>
                 <span class="mfrac" id="MathJax-Span-67">
                  <span class="mrow" id="MathJax-Span-68">
                   <span class="msubsup" id="MathJax-Span-69">
                    <span class="mi" id="MathJax-Span-70">
                     N
                    </span>
                    <span class="texatom" id="MathJax-Span-71">
                     <span class="mrow" id="MathJax-Span-72">
                      <span class="mi" id="MathJax-Span-73">
                       ¬
                      </span>
                     </span>
                    </span>
                    <span class="texatom" id="MathJax-Span-74">
                     <span class="mrow" id="MathJax-Span-75">
                      <span class="mi" id="MathJax-Span-76">
                       w
                      </span>
                      <span class="mi" id="MathJax-Span-77">
                       t
                      </span>
                     </span>
                    </span>
                   </span>
                   <span class="mo" id="MathJax-Span-78">
                    +
                   </span>
                   <span class="mi" id="MathJax-Span-79">
                    β
                   </span>
                  </span>
                  <span class="mrow" id="MathJax-Span-80">
                   <span class="msubsup" id="MathJax-Span-81">
                    <span class="mi" id="MathJax-Span-82">
                     N
                    </span>
                    <span class="texatom" id="MathJax-Span-83">
                     <span class="mrow" id="MathJax-Span-84">
                      <span class="mi" id="MathJax-Span-85">
                       ¬
                      </span>
                     </span>
                    </span>
                    <span class="mi" id="MathJax-Span-86">
                     t
                    </span>
                   </span>
                   <span class="mo" id="MathJax-Span-87">
                    +
                   </span>
                   <span class="mi" id="MathJax-Span-88">
                    β
                   </span>
                   <span class="mi" id="MathJax-Span-89">
                    V
                   </span>
                  </span>
                 </span>
                 <span class="mo" id="MathJax-Span-90">
                  ⋅
                 </span>
                 <span class="mfrac" id="MathJax-Span-91">
                  <span class="mrow" id="MathJax-Span-92">
                   <span class="msubsup" id="MathJax-Span-93">
                    <span class="mi" id="MathJax-Span-94">
                     N
                    </span>
                    <span class="texatom" id="MathJax-Span-95">
                     <span class="mrow" id="MathJax-Span-96">
                      <span class="mi" id="MathJax-Span-97">
                       ¬
                      </span>
                     </span>
                    </span>
                    <span class="texatom" id="MathJax-Span-98">
                     <span class="mrow" id="MathJax-Span-99">
                      <span class="mi" id="MathJax-Span-100">
                       t
                      </span>
                      <span class="mi" id="MathJax-Span-101">
                       d
                      </span>
                     </span>
                    </span>
                   </span>
                   <span class="mo" id="MathJax-Span-102">
                    +
                   </span>
                   <span class="msubsup" id="MathJax-Span-103">
                    <span class="mi" id="MathJax-Span-104">
                     α
                    </span>
                    <span class="mi" id="MathJax-Span-105">
                     t
                    </span>
                   </span>
                  </span>
                  <span class="mrow" id="MathJax-Span-106">
                   <span class="msubsup" id="MathJax-Span-107">
                    <span class="mi" id="MathJax-Span-108">
                     L
                    </span>
                    <span class="mi" id="MathJax-Span-109">
                     d
                    </span>
                   </span>
                   <span class="mo" id="MathJax-Span-110">
                    –
                   </span>
                   <span class="mn" id="MathJax-Span-111">
                    1
                   </span>
                   <span class="mo" id="MathJax-Span-112">
                    +
                   </span>
                   <span class="munderover" id="MathJax-Span-113">
                    <span class="mo" id="MathJax-Span-114">
                     ∑
                    </span>
                    <span class="mi" id="MathJax-Span-115">
                     t
                    </span>
                   </span>
                   <span class="msubsup" id="MathJax-Span-116">
                    <span class="mi" id="MathJax-Span-117">
                     α
                    </span>
                    <span class="mi" id="MathJax-Span-118">
                     t
                    </span>
                   </span>
                  </span>
                 </span>
                </span>
               </span>
               <span class="mtd" id="MathJax-Span-121">
                <span class="mrow" id="MathJax-Span-122">
                 <span class="mo" id="MathJax-Span-123">
                  ∝
                 </span>
                 <span class="mfrac" id="MathJax-Span-124">
                  <span class="mrow" id="MathJax-Span-125">
                   <span class="msubsup" id="MathJax-Span-126">
                    <span class="mi" id="MathJax-Span-127">
                     N
                    </span>
                    <span class="texatom" id="MathJax-Span-128">
                     <span class="mrow" id="MathJax-Span-129">
                      <span class="mi" id="MathJax-Span-130">
                       ¬
                      </span>
                     </span>
                    </span>
                    <span class="texatom" id="MathJax-Span-131">
                     <span class="mrow" id="MathJax-Span-132">
                      <span class="mi" id="MathJax-Span-133">
                       w
                      </span>
                      <span class="mi" id="MathJax-Span-134">
                       t
                      </span>
                     </span>
                    </span>
                   </span>
                   <span class="mo" id="MathJax-Span-135">
                    +
                   </span>
                   <span class="mi" id="MathJax-Span-136">
                    β
                   </span>
                  </span>
                  <span class="mrow" id="MathJax-Span-137">
                   <span class="msubsup" id="MathJax-Span-138">
                    <span class="mi" id="MathJax-Span-139">
                     N
                    </span>
                    <span class="texatom" id="MathJax-Span-140">
                     <span class="mrow" id="MathJax-Span-141">
                      <span class="mi" id="MathJax-Span-142">
                       ¬
                      </span>
                     </span>
                    </span>
                    <span class="mi" id="MathJax-Span-143">
                     t
                    </span>
                   </span>
                   <span class="mo" id="MathJax-Span-144">
                    +
                   </span>
                   <span class="mi" id="MathJax-Span-145">
                    β
                   </span>
                   <span class="mi" id="MathJax-Span-146">
                    V
                   </span>
                  </span>
                 </span>
                 <span class="mo" id="MathJax-Span-147">
                  (
                 </span>
                 <span class="msubsup" id="MathJax-Span-148">
                  <span class="mi" id="MathJax-Span-149">
                   N
                  </span>
                  <span class="texatom" id="MathJax-Span-150">
                   <span class="mrow" id="MathJax-Span-151">
                    <span class="mi" id="MathJax-Span-152">
                     ¬
                    </span>
                   </span>
                  </span>
                  <span class="texatom" id="MathJax-Span-153">
                   <span class="mrow" id="MathJax-Span-154">
                    <span class="mi" id="MathJax-Span-155">
                     t
                    </span>
                    <span class="mi" id="MathJax-Span-156">
                     d
                    </span>
                   </span>
                  </span>
                 </span>
                 <span class="mo" id="MathJax-Span-157">
                  +
                 </span>
                 <span class="msubsup" id="MathJax-Span-158">
                  <span class="mi" id="MathJax-Span-159">
                   α
                  </span>
                  <span class="mi" id="MathJax-Span-160">
                   t
                  </span>
                 </span>
                 <span class="mo" id="MathJax-Span-161">
                  )
                 </span>
                </span>
               </span>
              </span>
             </span>
            </span>
            <span class="mtd" id="mjx-eqn-eqsampling">
             <span class="mrow" id="MathJax-Span-45">
              <span class="mtext" id="mjx-eqn-1">
               (1)
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
       </div>
       <p>
        其中
        <span class="MathJax" id="MathJax-Element-7-Frame">
         <span class="math" id="MathJax-Span-162">
          <span class="mrow" id="MathJax-Span-163">
           <span class="msubsup" id="MathJax-Span-164">
            <span class="mi" id="MathJax-Span-165">
             α
            </span>
            <span class="mi" id="MathJax-Span-166">
             t
            </span>
           </span>
          </span>
         </span>
        </span>
        和
        <span class="MathJax" id="MathJax-Element-8-Frame">
         <span class="math" id="MathJax-Span-167">
          <span class="mrow" id="MathJax-Span-168">
           <span class="mi" id="MathJax-Span-169">
            β
           </span>
          </span>
         </span>
        </span>
        是超参数，分别表示对
        <span class="MathJax" id="MathJax-Element-9-Frame">
         <span class="math" id="MathJax-Span-170">
          <span class="mrow" id="MathJax-Span-171">
           <span class="msubsup" id="MathJax-Span-172">
            <span class="mi" id="MathJax-Span-173">
             N
            </span>
            <span class="texatom" id="MathJax-Span-174">
             <span class="mrow" id="MathJax-Span-175">
              <span class="mi" id="MathJax-Span-176">
               t
              </span>
              <span class="mi" id="MathJax-Span-177">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        和
        <span class="MathJax" id="MathJax-Element-10-Frame">
         <span class="math" id="MathJax-Span-178">
          <span class="mrow" id="MathJax-Span-179">
           <span class="msubsup" id="MathJax-Span-180">
            <span class="mi" id="MathJax-Span-181">
             N
            </span>
            <span class="texatom" id="MathJax-Span-182">
             <span class="mrow" id="MathJax-Span-183">
              <span class="mi" id="MathJax-Span-184">
               w
              </span>
              <span class="mi" id="MathJax-Span-185">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        中的频率计数进行概率平滑；
        <em>
         V
        </em>
        为词表大小，
        <span class="MathJax" id="MathJax-Element-11-Frame">
         <span class="math" id="MathJax-Span-186">
          <span class="mrow" id="MathJax-Span-187">
           <span class="msubsup" id="MathJax-Span-188">
            <span class="mi" id="MathJax-Span-189">
             L
            </span>
            <span class="mi" id="MathJax-Span-190">
             d
            </span>
           </span>
          </span>
         </span>
        </span>
        表示文档
        <em>
         d
        </em>
        长度，
        <span class="MathJax" id="MathJax-Element-12-Frame">
         <span class="math" id="MathJax-Span-191">
          <span class="mrow" id="MathJax-Span-192">
           <span class="msubsup" id="MathJax-Span-193">
            <span class="mi" id="MathJax-Span-194">
             N
            </span>
            <span class="texatom" id="MathJax-Span-195">
             <span class="mrow" id="MathJax-Span-196">
              <span class="mi" id="MathJax-Span-197">
               w
              </span>
              <span class="mi" id="MathJax-Span-198">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        表示训练语料中主题
        <em>
         t
        </em>
        中词
        <em>
         w
        </em>
        的出现次数，
        <span class="MathJax" id="MathJax-Element-13-Frame">
         <span class="math" id="MathJax-Span-199">
          <span class="mrow" id="MathJax-Span-200">
           <span class="msubsup" id="MathJax-Span-201">
            <span class="mi" id="MathJax-Span-202">
             N
            </span>
            <span class="texatom" id="MathJax-Span-203">
             <span class="mrow" id="MathJax-Span-204">
              <span class="mi" id="MathJax-Span-205">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        表示训练语料中主题
        <em>
         t
        </em>
        的出现次数，
        <span class="MathJax" id="MathJax-Element-14-Frame">
         <span class="math" id="MathJax-Span-206">
          <span class="mrow" id="MathJax-Span-207">
           <span class="msubsup" id="MathJax-Span-208">
            <span class="mi" id="MathJax-Span-209">
             N
            </span>
            <span class="texatom" id="MathJax-Span-210">
             <span class="mrow" id="MathJax-Span-211">
              <span class="mi" id="MathJax-Span-212">
               t
              </span>
              <span class="mi" id="MathJax-Span-213">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        表示文档
        <em>
         d
        </em>
        中主题
        <em>
         t
        </em>
        的出现次数，上角标
        <span class="MathJax" id="MathJax-Element-15-Frame">
         <span class="math" id="MathJax-Span-214">
          <span class="mrow" id="MathJax-Span-215">
           <span class="mi" id="MathJax-Span-216">
            ¬
           </span>
          </span>
         </span>
        </span>
        表示剔除当前采样词
        <em>
         w
        </em>
        的影响（比如
        <span class="MathJax" id="MathJax-Element-16-Frame">
         <span class="math" id="MathJax-Span-217">
          <span class="mrow" id="MathJax-Span-218">
           <span class="msubsup" id="MathJax-Span-219">
            <span class="mi" id="MathJax-Span-220">
             N
            </span>
            <span class="texatom" id="MathJax-Span-221">
             <span class="mrow" id="MathJax-Span-222">
              <span class="mi" id="MathJax-Span-223">
               ¬
              </span>
             </span>
            </span>
            <span class="texatom" id="MathJax-Span-224">
             <span class="mrow" id="MathJax-Span-225">
              <span class="mi" id="MathJax-Span-226">
               t
              </span>
              <span class="mi" id="MathJax-Span-227">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        表示减去当前采样词对应的主题后，文档
        <em>
         d
        </em>
        中主题
        <em>
         t
        </em>
        的出现次数）。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f15.jpg"/>
        <br/>
        <strong>
         图15 文档
         <span class="MathJax" id="MathJax-Element-17-Frame">
          <span class="math" id="MathJax-Span-228">
           <span class="mrow" id="MathJax-Span-229">
            <span class="msubsup" id="MathJax-Span-230">
             <span class="mi" id="MathJax-Span-231">
              d
             </span>
             <span class="mn" id="MathJax-Span-232">
              1
             </span>
            </span>
           </span>
          </span>
         </span>
         中词
         <em>
          w
         </em>
         主题重新采样
        </strong>
       </div>
       <div>
       </div>
       <p>
        事实上，以上对文档
        <em>
         d
        </em>
        中词w的主题z进行重新采样的公式有非常明确的物理意义，表示P(w|z)P(z|d)，可以如图15直观的表示为一个“路径选择”的过程：
       </p>
       <ul>
        <li>
         对当前文档
         <em>
          d
         </em>
         中的当前词
         <em>
          w
         </em>
         （图15中黑体表示），词
         <em>
          w
         </em>
         的“旧”主题
         <em>
          z
         </em>
         给出了
         <em>
          d-z-w
         </em>
         的一条路径（图15（1）虚线）；
        </li>
        <li>
         剔除词
         <em>
          w
         </em>
         对应的“旧”主题
         <em>
          z
         </em>
         <em>
          ，
         </em>
         更新在
         <span class="MathJax" id="MathJax-Element-18-Frame">
          <span class="math" id="MathJax-Span-233">
           <span class="mrow" id="MathJax-Span-234">
            <span class="msubsup" id="MathJax-Span-235">
             <span class="mi" id="MathJax-Span-236">
              N
             </span>
             <span class="texatom" id="MathJax-Span-237">
              <span class="mrow" id="MathJax-Span-238">
               <span class="mi" id="MathJax-Span-239">
                w
               </span>
               <span class="mi" id="MathJax-Span-240">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         和
         <span class="MathJax" id="MathJax-Element-19-Frame">
          <span class="math" id="MathJax-Span-241">
           <span class="mrow" id="MathJax-Span-242">
            <span class="msubsup" id="MathJax-Span-243">
             <span class="mi" id="MathJax-Span-244">
              N
             </span>
             <span class="texatom" id="MathJax-Span-245">
              <span class="mrow" id="MathJax-Span-246">
               <span class="mi" id="MathJax-Span-247">
                t
               </span>
               <span class="mi" id="MathJax-Span-248">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         中的计数（图15（1）在旧路径对应的两条边上做 “-1”操作）；
        </li>
        <li>
         计算
         <em>
          d-z-w
         </em>
         的每一条可能路径的概率，
         <em>
          d-z-w
         </em>
         路径的概率等于
         <em>
          d-z
         </em>
         和
         <em>
          z-w
         </em>
         两部分路径概率的乘积即P(z|d)P(w|z)，P(z|d)和
         <span class="MathJax" id="MathJax-Element-20-Frame">
          <span class="math" id="MathJax-Span-249">
           <span class="mrow" id="MathJax-Span-250">
            <span class="msubsup" id="MathJax-Span-251">
             <span class="mi" id="MathJax-Span-252">
              N
             </span>
             <span class="texatom" id="MathJax-Span-253">
              <span class="mrow" id="MathJax-Span-254">
               <span class="mi" id="MathJax-Span-255">
                t
               </span>
               <span class="mi" id="MathJax-Span-256">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         有关，P(w|z)和
         <span class="MathJax" id="MathJax-Element-21-Frame">
          <span class="math" id="MathJax-Span-257">
           <span class="mrow" id="MathJax-Span-258">
            <span class="msubsup" id="MathJax-Span-259">
             <span class="mi" id="MathJax-Span-260">
              N
             </span>
             <span class="texatom" id="MathJax-Span-261">
              <span class="mrow" id="MathJax-Span-262">
               <span class="mi" id="MathJax-Span-263">
                w
               </span>
               <span class="mi" id="MathJax-Span-264">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         有关（图15（1））；
        </li>
        <li>
         依据概率对
         <em>
          d-z-w
         </em>
         路径进行采样，得到词
         <em>
          w
         </em>
         的“新”主题
         <em>
          z
         </em>
         （图15（2）虚线）；
        </li>
        <li>
         增加词
         <em>
          w
         </em>
         对应的“新”主题
         <em>
          z
         </em>
         ，更新在
         <span class="MathJax" id="MathJax-Element-22-Frame">
          <span class="math" id="MathJax-Span-265">
           <span class="mrow" id="MathJax-Span-266">
            <span class="msubsup" id="MathJax-Span-267">
             <span class="mi" id="MathJax-Span-268">
              N
             </span>
             <span class="texatom" id="MathJax-Span-269">
              <span class="mrow" id="MathJax-Span-270">
               <span class="mi" id="MathJax-Span-271">
                w
               </span>
               <span class="mi" id="MathJax-Span-272">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         和
         <span class="MathJax" id="MathJax-Element-23-Frame">
          <span class="math" id="MathJax-Span-273">
           <span class="mrow" id="MathJax-Span-274">
            <span class="msubsup" id="MathJax-Span-275">
             <span class="mi" id="MathJax-Span-276">
              N
             </span>
             <span class="texatom" id="MathJax-Span-277">
              <span class="mrow" id="MathJax-Span-278">
               <span class="mi" id="MathJax-Span-279">
                t
               </span>
               <span class="mi" id="MathJax-Span-280">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         中的计数（图15（2）在新路径对应的两条边上做“+1”操作）。
        </li>
       </ul>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f16.jpg"/>
        <br/>
        <strong>
         图16 单机版LDA训练过程
        </strong>
       </div>
       <div>
       </div>
       <p>
        在训练模型时，为了包含尽可能多的隐含语义（主题）同时保证效果，通常会使用海量的训练语料。这些互联网原始文档语料经过切词、停用词过滤、文档过滤（长度）等预处理步骤后（通常会分块进行存储），就可以作为LDA训练器的输入了。图14描述的LDA训练过程，在更大范围的训练语料上来看，如图16所示：
       </p>
       <ul>
        <li>
         训练语料数据块中会保存文档中的词和对应的主题
         <em>
          (W,T)
         </em>
         ，以及文档对应的主题直方图
         <span class="MathJax" id="MathJax-Element-24-Frame">
          <span class="math" id="MathJax-Span-281">
           <span class="mrow" id="MathJax-Span-282">
            <span class="msubsup" id="MathJax-Span-283">
             <span class="mi" id="MathJax-Span-284">
              N
             </span>
             <span class="texatom" id="MathJax-Span-285">
              <span class="mrow" id="MathJax-Span-286">
               <span class="mi" id="MathJax-Span-287">
                t
               </span>
               <span class="mi" id="MathJax-Span-288">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ；
        </li>
        <li>
         训练器内存中保存一份
         <span class="MathJax" id="MathJax-Element-25-Frame">
          <span class="math" id="MathJax-Span-289">
           <span class="mrow" id="MathJax-Span-290">
            <span class="msubsup" id="MathJax-Span-291">
             <span class="mi" id="MathJax-Span-292">
              N
             </span>
             <span class="texatom" id="MathJax-Span-293">
              <span class="mrow" id="MathJax-Span-294">
               <span class="mi" id="MathJax-Span-295">
                w
               </span>
               <span class="mi" id="MathJax-Span-296">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ；
        </li>
        <li>
         训练器依次加载训练语料数据块，并对其中的所有词
         <em>
          W
         </em>
         的主题
         <em>
          T
         </em>
         进行采样，采样的同时会更新
         <span class="MathJax" id="MathJax-Element-26-Frame">
          <span class="math" id="MathJax-Span-297">
           <span class="mrow" id="MathJax-Span-298">
            <span class="msubsup" id="MathJax-Span-299">
             <span class="mi" id="MathJax-Span-300">
              N
             </span>
             <span class="texatom" id="MathJax-Span-301">
              <span class="mrow" id="MathJax-Span-302">
               <span class="mi" id="MathJax-Span-303">
                w
               </span>
               <span class="mi" id="MathJax-Span-304">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         、
         <span class="MathJax" id="MathJax-Element-27-Frame">
          <span class="math" id="MathJax-Span-305">
           <span class="mrow" id="MathJax-Span-306">
            <span class="msubsup" id="MathJax-Span-307">
             <span class="mi" id="MathJax-Span-308">
              N
             </span>
             <span class="texatom" id="MathJax-Span-309">
              <span class="mrow" id="MathJax-Span-310">
               <span class="mi" id="MathJax-Span-311">
                t
               </span>
               <span class="mi" id="MathJax-Span-312">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         和文档中词
         <em>
          W
         </em>
         的主题
         <em>
          T
         </em>
         ；
        </li>
        <li>
         采样完成一个数据块后，训练器将更新后的
         <em>
          (W,T)
         </em>
         和
         <span class="MathJax" id="MathJax-Element-28-Frame">
          <span class="math" id="MathJax-Span-313">
           <span class="mrow" id="MathJax-Span-314">
            <span class="msubsup" id="MathJax-Span-315">
             <span class="mi" id="MathJax-Span-316">
              N
             </span>
             <span class="texatom" id="MathJax-Span-317">
              <span class="mrow" id="MathJax-Span-318">
               <span class="mi" id="MathJax-Span-319">
                t
               </span>
               <span class="mi" id="MathJax-Span-320">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         序列化到磁盘上，供下一个迭代加载采样；
        </li>
        <li>
         所有迭代结束，
         <span class="MathJax" id="MathJax-Element-29-Frame">
          <span class="math" id="MathJax-Span-321">
           <span class="mrow" id="MathJax-Span-322">
            <span class="msubsup" id="MathJax-Span-323">
             <span class="mi" id="MathJax-Span-324">
              N
             </span>
             <span class="texatom" id="MathJax-Span-325">
              <span class="mrow" id="MathJax-Span-326">
               <span class="mi" id="MathJax-Span-327">
                w
               </span>
               <span class="mi" id="MathJax-Span-328">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         收敛，训练器根据
         <span class="MathJax" id="MathJax-Element-30-Frame">
          <span class="math" id="MathJax-Span-329">
           <span class="mrow" id="MathJax-Span-330">
            <span class="msubsup" id="MathJax-Span-331">
             <span class="mi" id="MathJax-Span-332">
              N
             </span>
             <span class="texatom" id="MathJax-Span-333">
              <span class="mrow" id="MathJax-Span-334">
               <span class="mi" id="MathJax-Span-335">
                w
               </span>
               <span class="mi" id="MathJax-Span-336">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         计算出模型并输出。
        </li>
       </ul>
       <p>
        基于吉布斯采样的LDA在线推断过程与训练过程（图14）类似：给定文档，采样更新其中每一个词
        <em>
         w
        </em>
        对应的主题
        <em>
         z
        </em>
        （采样公式同上，采样过程中可以保持模型
        <span class="MathJax" id="MathJax-Element-31-Frame">
         <span class="math" id="MathJax-Span-337">
          <span class="mrow" id="MathJax-Span-338">
           <span class="msubsup" id="MathJax-Span-339">
            <span class="mi" id="MathJax-Span-340">
             N
            </span>
            <span class="texatom" id="MathJax-Span-341">
             <span class="mrow" id="MathJax-Span-342">
              <span class="mi" id="MathJax-Span-343">
               w
              </span>
              <span class="mi" id="MathJax-Span-344">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        不变）；重复上述过程，直到文档主题直方图
        <span class="MathJax" id="MathJax-Element-32-Frame">
         <span class="math" id="MathJax-Span-345">
          <span class="mrow" id="MathJax-Span-346">
           <span class="msubsup" id="MathJax-Span-347">
            <span class="mi" id="MathJax-Span-348">
             N
            </span>
            <span class="texatom" id="MathJax-Span-349">
             <span class="mrow" id="MathJax-Span-350">
              <span class="mi" id="MathJax-Span-351">
               t
              </span>
              <span class="mi" id="MathJax-Span-352">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        收敛，使用
        <span class="MathJax" id="MathJax-Element-33-Frame">
         <span class="math" id="MathJax-Span-353">
          <span class="mrow" id="MathJax-Span-354">
           <span class="msubsup" id="MathJax-Span-355">
            <span class="mi" id="MathJax-Span-356">
             α
            </span>
            <span class="mi" id="MathJax-Span-357">
             t
            </span>
           </span>
          </span>
         </span>
        </span>
        对其进行简单平滑即为文档主题向量。
       </p>
       <h3>
        三、十亿文档、百万词汇、百万主题？
       </h3>
       <p>
        从上一个小节的算法描述中，我们可以看到LDA 的训练算法貌似并不复杂，主要的工作就是在维护两个频率计数矩阵
        <span class="MathJax" id="MathJax-Element-34-Frame">
         <span class="math" id="MathJax-Span-358">
          <span class="mrow" id="MathJax-Span-359">
           <span class="msubsup" id="MathJax-Span-360">
            <span class="mi" id="MathJax-Span-361">
             N
            </span>
            <span class="texatom" id="MathJax-Span-362">
             <span class="mrow" id="MathJax-Span-363">
              <span class="mi" id="MathJax-Span-364">
               w
              </span>
              <span class="mi" id="MathJax-Span-365">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        和
        <span class="MathJax" id="MathJax-Element-35-Frame">
         <span class="math" id="MathJax-Span-366">
          <span class="mrow" id="MathJax-Span-367">
           <span class="msubsup" id="MathJax-Span-368">
            <span class="mi" id="MathJax-Span-369">
             N
            </span>
            <span class="texatom" id="MathJax-Span-370">
             <span class="mrow" id="MathJax-Span-371">
              <span class="mi" id="MathJax-Span-372">
               t
              </span>
              <span class="mi" id="MathJax-Span-373">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        。然而在这个时代，我们要面对的是互联网的海量数据，想象一下，如果在图15中，左边的文档节点是十亿、中间的主题个数是百万、右边不同的词的个数也是百万，我们将需要处理一张多大的图！！！在实际应用中，我们希望使用更多的数据训练更大的模型，这包含了两重意思：
       </p>
       <ul>
        <li>
         “更多的数据”，我们希望训练器能处理海量的训练数据，因为更多的数据蕴含着更加丰富的隐含语义，同时模型也更加准确，效果更好。上一小节提到单机版LDA训练器显然是处理不了海量数据的，使用它训练模型，我们估计要等到天荒地老了。
        </li>
        <li>
         “更大的模型”，我们希望训练器能归纳出更多更具体更长尾的隐含语义，比如一百万主题。抛开标准LDA算法本身的问题，更大的模型意味着矩阵
         <span class="MathJax" id="MathJax-Element-36-Frame">
          <span class="math" id="MathJax-Span-374">
           <span class="mrow" id="MathJax-Span-375">
            <span class="msubsup" id="MathJax-Span-376">
             <span class="mi" id="MathJax-Span-377">
              N
             </span>
             <span class="texatom" id="MathJax-Span-378">
              <span class="mrow" id="MathJax-Span-379">
               <span class="mi" id="MathJax-Span-380">
                w
               </span>
               <span class="mi" id="MathJax-Span-381">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         规模更大。
         <span class="MathJax" id="MathJax-Element-37-Frame">
          <span class="math" id="MathJax-Span-382">
           <span class="mrow" id="MathJax-Span-383">
            <span class="msubsup" id="MathJax-Span-384">
             <span class="mi" id="MathJax-Span-385">
              N
             </span>
             <span class="texatom" id="MathJax-Span-386">
              <span class="mrow" id="MathJax-Span-387">
               <span class="mi" id="MathJax-Span-388">
                w
               </span>
               <span class="mi" id="MathJax-Span-389">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         的大小为
         <em>
          VxK
         </em>
         ，
         <em>
          V
         </em>
         表示词表大小，
         <em>
          K
         </em>
         表示主题个数。取
         <em>
          V=1,000,000
         </em>
         且
         <em>
          K=1,000,000
         </em>
         ，
         <span class="MathJax" id="MathJax-Element-38-Frame">
          <span class="math" id="MathJax-Span-390">
           <span class="mrow" id="MathJax-Span-391">
            <span class="msubsup" id="MathJax-Span-392">
             <span class="mi" id="MathJax-Span-393">
              N
             </span>
             <span class="texatom" id="MathJax-Span-394">
              <span class="mrow" id="MathJax-Span-395">
               <span class="mi" id="MathJax-Span-396">
                w
               </span>
               <span class="mi" id="MathJax-Span-397">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         需要消耗3000G以上内存（假设int型密集存储，因为模型随机初始化并不稀疏），显然单机内存是无法满足需求的，必须对模型进行切分。
        </li>
       </ul>
       <p>
        下面分别从数据并行和模型并行两个方面来介绍怎样解决上述两个问题。“数据并行”和“模型并行“是Google大神Jeff Dean在深度学习训练系统DistBelief
        <sup>
         [13]
        </sup>
        中新提出的两个概念，尽管Peacock系统开发的时候，DistBelief还没有真正对外公布。随着深度学习的持续升温，大家现在已经逐渐熟悉了这两个形象的名词，此处请允许我们借用一下这两个概念。
       </p>
       <h4>
        3.1 数据并行——处理更多的数据
       </h4>
       <p>
        “数据并行”通俗的理解：通过多任务（每个任务都包含一份完整的模型）并行的处理数据训练模型，任务之间的模型或同步或异步的进行融合。借用王益
        <sup>
         [3]
        </sup>
        的说法，“如果一个算法可以做数据并行，很可能就是可扩展的了”。幸运的是，David Newman团队发现基于吉布斯采样的LDA训练算法可以“数据并行”，并给这个算法取了一个名字叫AD-LDA
        <sup>
         [14]
        </sup>
        。
       </p>
       <p>
        注意，AD-LDA算法是吉布斯采样的近似算法，因为严格的吉布斯采样要求串行采样，不能并行。直观的理解就是语料中前一个词
        <span class="MathJax" id="MathJax-Element-39-Frame">
         <span class="math" id="MathJax-Span-398">
          <span class="mrow" id="MathJax-Span-399">
           <span class="msubsup" id="MathJax-Span-400">
            <span class="mi" id="MathJax-Span-401">
             w
            </span>
            <span class="mn" id="MathJax-Span-402">
             1
            </span>
           </span>
          </span>
         </span>
        </span>
        采样更新后的
        <span class="MathJax" id="MathJax-Element-40-Frame">
         <span class="math" id="MathJax-Span-403">
          <span class="mrow" id="MathJax-Span-404">
           <span class="msubsup" id="MathJax-Span-405">
            <span class="mi" id="MathJax-Span-406">
             N
            </span>
            <span class="texatom" id="MathJax-Span-407">
             <span class="mrow" id="MathJax-Span-408">
              <span class="mi" id="MathJax-Span-409">
               w
              </span>
              <span class="mi" id="MathJax-Span-410">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        和
        <span class="MathJax" id="MathJax-Element-41-Frame">
         <span class="math" id="MathJax-Span-411">
          <span class="mrow" id="MathJax-Span-412">
           <span class="msubsup" id="MathJax-Span-413">
            <span class="mi" id="MathJax-Span-414">
             N
            </span>
            <span class="mi" id="MathJax-Span-415">
             t
            </span>
           </span>
          </span>
         </span>
        </span>
        应该应用于后一个词
        <span class="MathJax" id="MathJax-Element-42-Frame">
         <span class="math" id="MathJax-Span-416">
          <span class="mrow" id="MathJax-Span-417">
           <span class="msubsup" id="MathJax-Span-418">
            <span class="mi" id="MathJax-Span-419">
             w
            </span>
            <span class="mn" id="MathJax-Span-420">
             2
            </span>
           </span>
          </span>
         </span>
        </span>
        的采样，而不是
        <span class="MathJax" id="MathJax-Element-43-Frame">
         <span class="math" id="MathJax-Span-421">
          <span class="mrow" id="MathJax-Span-422">
           <span class="msubsup" id="MathJax-Span-423">
            <span class="mi" id="MathJax-Span-424">
             w
            </span>
            <span class="mn" id="MathJax-Span-425">
             1
            </span>
           </span>
          </span>
         </span>
        </span>
        和
        <span class="MathJax" id="MathJax-Element-44-Frame">
         <span class="math" id="MathJax-Span-426">
          <span class="mrow" id="MathJax-Span-427">
           <span class="msubsup" id="MathJax-Span-428">
            <span class="mi" id="MathJax-Span-429">
             w
            </span>
            <span class="mn" id="MathJax-Span-430">
             2
            </span>
           </span>
          </span>
         </span>
        </span>
        的采样都基于相同状态的
        <span class="MathJax" id="MathJax-Element-45-Frame">
         <span class="math" id="MathJax-Span-431">
          <span class="mrow" id="MathJax-Span-432">
           <span class="msubsup" id="MathJax-Span-433">
            <span class="mi" id="MathJax-Span-434">
             N
            </span>
            <span class="texatom" id="MathJax-Span-435">
             <span class="mrow" id="MathJax-Span-436">
              <span class="mi" id="MathJax-Span-437">
               w
              </span>
              <span class="mi" id="MathJax-Span-438">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        和
        <span class="MathJax" id="MathJax-Element-46-Frame">
         <span class="math" id="MathJax-Span-439">
          <span class="mrow" id="MathJax-Span-440">
           <span class="msubsup" id="MathJax-Span-441">
            <span class="mi" id="MathJax-Span-442">
             N
            </span>
            <span class="mi" id="MathJax-Span-443">
             t
            </span>
           </span>
          </span>
         </span>
        </span>
        。AD-LDA算法会使得LDA的训练收敛速度变慢，但在多几轮迭代后，AD-LDA算法可以收敛到与串行吉布斯采样相同的点。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f17.jpg"/>
        <br/>
        <strong>
         图17 AD-LDA算法
        </strong>
       </div>
       <div>
       </div>
       <p>
        图17给出了AD-LDA算法的示意图：
       </p>
       <ul>
        <li>
         假设我们有三个可执行单元，每个都启动一个采样任务，每个任务中都有一个完整的“本地”模型
         <span class="MathJax" id="MathJax-Element-47-Frame">
          <span class="math" id="MathJax-Span-444">
           <span class="mrow" id="MathJax-Span-445">
            <span class="mi" id="MathJax-Span-446">
             L
            </span>
            <span class="msubsup" id="MathJax-Span-447">
             <span class="mi" id="MathJax-Span-448">
              N
             </span>
             <span class="texatom" id="MathJax-Span-449">
              <span class="mrow" id="MathJax-Span-450">
               <span class="mi" id="MathJax-Span-451">
                w
               </span>
               <span class="mi" id="MathJax-Span-452">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ；
        </li>
        <li>
         任务并行的处理训练语料数据块
         <em>
          (W,T)
         </em>
         和
         <span class="MathJax" id="MathJax-Element-48-Frame">
          <span class="math" id="MathJax-Span-453">
           <span class="mrow" id="MathJax-Span-454">
            <span class="msubsup" id="MathJax-Span-455">
             <span class="mi" id="MathJax-Span-456">
              N
             </span>
             <span class="texatom" id="MathJax-Span-457">
              <span class="mrow" id="MathJax-Span-458">
               <span class="mi" id="MathJax-Span-459">
                t
               </span>
               <span class="mi" id="MathJax-Span-460">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ，更新模型
         <span class="MathJax" id="MathJax-Element-49-Frame">
          <span class="math" id="MathJax-Span-461">
           <span class="mrow" id="MathJax-Span-462">
            <span class="mi" id="MathJax-Span-463">
             L
            </span>
            <span class="msubsup" id="MathJax-Span-464">
             <span class="mi" id="MathJax-Span-465">
              N
             </span>
             <span class="texatom" id="MathJax-Span-466">
              <span class="mrow" id="MathJax-Span-467">
               <span class="mi" id="MathJax-Span-468">
                w
               </span>
               <span class="mi" id="MathJax-Span-469">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ，同时序列化更新后的训练语料数据块
         <em>
          (W,T)
         </em>
         和
         <span class="MathJax" id="MathJax-Element-50-Frame">
          <span class="math" id="MathJax-Span-470">
           <span class="mrow" id="MathJax-Span-471">
            <span class="msubsup" id="MathJax-Span-472">
             <span class="mi" id="MathJax-Span-473">
              N
             </span>
             <span class="texatom" id="MathJax-Span-474">
              <span class="mrow" id="MathJax-Span-475">
               <span class="mi" id="MathJax-Span-476">
                t
               </span>
               <span class="mi" id="MathJax-Span-477">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         到磁盘；
        </li>
        <li>
         在迭代结束或任务处理训练语料数据块过程中，任务之间或同步或异步的融合模型。模型融合的方式可以类似MPI中的AllReduce，也可以借助全局的参数服务器
         <span class="MathJax" id="MathJax-Element-51-Frame">
          <span class="math" id="MathJax-Span-478">
           <span class="mrow" id="MathJax-Span-479">
            <span class="mi" id="MathJax-Span-480">
             G
            </span>
            <span class="msubsup" id="MathJax-Span-481">
             <span class="mi" id="MathJax-Span-482">
              N
             </span>
             <span class="texatom" id="MathJax-Span-483">
              <span class="mrow" id="MathJax-Span-484">
               <span class="mi" id="MathJax-Span-485">
                w
               </span>
               <span class="mi" id="MathJax-Span-486">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         。
        </li>
       </ul>
       <p>
        AD-LDA算法的整个过程和MapReduce的执行过程非常一致，所以早期有非常多的团队使用MapReduce来实现AD-LDA算法
        <sup>
         [5]
        </sup>
        ：
       </p>
       <ul>
        <li>
         MapReduce的一个Job进行AD-LDA算法的一个迭代；
        </li>
        <li>
         训练语料数据块
         <em>
          (W,T)
         </em>
         和
         <span class="MathJax" id="MathJax-Element-52-Frame">
          <span class="math" id="MathJax-Span-487">
           <span class="mrow" id="MathJax-Span-488">
            <span class="msubsup" id="MathJax-Span-489">
             <span class="mi" id="MathJax-Span-490">
              N
             </span>
             <span class="texatom" id="MathJax-Span-491">
              <span class="mrow" id="MathJax-Span-492">
               <span class="mi" id="MathJax-Span-493">
                t
               </span>
               <span class="mi" id="MathJax-Span-494">
                d
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         作为Job输入，Mapper加载上个迭代生成的
         <span class="MathJax" id="MathJax-Element-53-Frame">
          <span class="math" id="MathJax-Span-495">
           <span class="mrow" id="MathJax-Span-496">
            <span class="mi" id="MathJax-Span-497">
             G
            </span>
            <span class="msubsup" id="MathJax-Span-498">
             <span class="mi" id="MathJax-Span-499">
              N
             </span>
             <span class="texatom" id="MathJax-Span-500">
              <span class="mrow" id="MathJax-Span-501">
               <span class="mi" id="MathJax-Span-502">
                w
               </span>
               <span class="mi" id="MathJax-Span-503">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         作为
         <span class="MathJax" id="MathJax-Element-54-Frame">
          <span class="math" id="MathJax-Span-504">
           <span class="mrow" id="MathJax-Span-505">
            <span class="mi" id="MathJax-Span-506">
             L
            </span>
            <span class="msubsup" id="MathJax-Span-507">
             <span class="mi" id="MathJax-Span-508">
              N
             </span>
             <span class="texatom" id="MathJax-Span-509">
              <span class="mrow" id="MathJax-Span-510">
               <span class="mi" id="MathJax-Span-511">
                w
               </span>
               <span class="mi" id="MathJax-Span-512">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ，对数据块中的词进行主题采样；
        </li>
        <li>
         Reducer融合各个
         <span class="MathJax" id="MathJax-Element-55-Frame">
          <span class="math" id="MathJax-Span-513">
           <span class="mrow" id="MathJax-Span-514">
            <span class="mi" id="MathJax-Span-515">
             L
            </span>
            <span class="msubsup" id="MathJax-Span-516">
             <span class="mi" id="MathJax-Span-517">
              N
             </span>
             <span class="texatom" id="MathJax-Span-518">
              <span class="mrow" id="MathJax-Span-519">
               <span class="mi" id="MathJax-Span-520">
                w
               </span>
               <span class="mi" id="MathJax-Span-521">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         ，生成下一个迭代需要加载的
         <span class="MathJax" id="MathJax-Element-56-Frame">
          <span class="math" id="MathJax-Span-522">
           <span class="mrow" id="MathJax-Span-523">
            <span class="mi" id="MathJax-Span-524">
             G
            </span>
            <span class="msubsup" id="MathJax-Span-525">
             <span class="mi" id="MathJax-Span-526">
              N
             </span>
             <span class="texatom" id="MathJax-Span-527">
              <span class="mrow" id="MathJax-Span-528">
               <span class="mi" id="MathJax-Span-529">
                w
               </span>
               <span class="mi" id="MathJax-Span-530">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         。
        </li>
       </ul>
       <p>
        因为MapReduce使用磁盘进行数据交换，同时整个训练任务需要调度几百个Jobs，所以基于MapReduce的AD-LDA实现是非常低效的。
       </p>
       <h4>
        3.2 模型并行——训练更大的模型
       </h4>
       <p>
        上文提到，训练大模型时，
        <span class="MathJax" id="MathJax-Element-57-Frame">
         <span class="math" id="MathJax-Span-531">
          <span class="mrow" id="MathJax-Span-532">
           <span class="msubsup" id="MathJax-Span-533">
            <span class="mi" id="MathJax-Span-534">
             N
            </span>
            <span class="texatom" id="MathJax-Span-535">
             <span class="mrow" id="MathJax-Span-536">
              <span class="mi" id="MathJax-Span-537">
               w
              </span>
              <span class="mi" id="MathJax-Span-538">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        太大而无法整体放入任务的内存，直观的解决方法如图18所示，将
        <span class="MathJax" id="MathJax-Element-58-Frame">
         <span class="math" id="MathJax-Span-539">
          <span class="mrow" id="MathJax-Span-540">
           <span class="msubsup" id="MathJax-Span-541">
            <span class="mi" id="MathJax-Span-542">
             N
            </span>
            <span class="texatom" id="MathJax-Span-543">
             <span class="mrow" id="MathJax-Span-544">
              <span class="mi" id="MathJax-Span-545">
               w
              </span>
              <span class="mi" id="MathJax-Span-546">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        沿词的维度进行分片，每个采样任务只加载一个模型分片
        <span class="MathJax" id="MathJax-Element-59-Frame">
         <span class="math" id="MathJax-Span-547">
          <span class="mrow" id="MathJax-Span-548">
           <span class="msubsup" id="MathJax-Span-549">
            <span class="mi" id="MathJax-Span-550">
             N
            </span>
            <span class="texatom" id="MathJax-Span-551">
             <span class="mrow" id="MathJax-Span-552">
              <span class="mo" id="MathJax-Span-553">
               (
              </span>
              <span class="mi" id="MathJax-Span-554">
               i
              </span>
              <span class="mo" id="MathJax-Span-555">
               )
              </span>
             </span>
            </span>
            <span class="texatom" id="MathJax-Span-556">
             <span class="mrow" id="MathJax-Span-557">
              <span class="mi" id="MathJax-Span-558">
               w
              </span>
              <span class="mi" id="MathJax-Span-559">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        。相应的，语料数据块也需要做对应的词维度切分，因为单个任务
        <em>
         i
        </em>
        只能采样
        <span class="MathJax" id="MathJax-Element-60-Frame">
         <span class="math" id="MathJax-Span-560">
          <span class="mrow" id="MathJax-Span-561">
           <span class="msubsup" id="MathJax-Span-562">
            <span class="mi" id="MathJax-Span-563">
             N
            </span>
            <span class="texatom" id="MathJax-Span-564">
             <span class="mrow" id="MathJax-Span-565">
              <span class="mo" id="MathJax-Span-566">
               (
              </span>
              <span class="mi" id="MathJax-Span-567">
               i
              </span>
              <span class="mo" id="MathJax-Span-568">
               )
              </span>
             </span>
            </span>
            <span class="texatom" id="MathJax-Span-569">
             <span class="mrow" id="MathJax-Span-570">
              <span class="mi" id="MathJax-Span-571">
               w
              </span>
              <span class="mi" id="MathJax-Span-572">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        包含的词
        <em>
         w
        </em>
        。细心的童鞋可能已经发现，图18所示的模型并行方式在
        <span class="MathJax" id="MathJax-Element-61-Frame">
         <span class="math" id="MathJax-Span-573">
          <span class="mrow" id="MathJax-Span-574">
           <span class="msubsup" id="MathJax-Span-575">
            <span class="mi" id="MathJax-Span-576">
             N
            </span>
            <span class="texatom" id="MathJax-Span-577">
             <span class="mrow" id="MathJax-Span-578">
              <span class="mi" id="MathJax-Span-579">
               t
              </span>
              <span class="mi" id="MathJax-Span-580">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        上采用了类似AD-LDA算法的近似，
        <span class="MathJax" id="MathJax-Element-62-Frame">
         <span class="math" id="MathJax-Span-581">
          <span class="mrow" id="MathJax-Span-582">
           <span class="mi" id="MathJax-Span-583">
            L
           </span>
           <span class="msubsup" id="MathJax-Span-584">
            <span class="mi" id="MathJax-Span-585">
             N
            </span>
            <span class="texatom" id="MathJax-Span-586">
             <span class="mrow" id="MathJax-Span-587">
              <span class="mi" id="MathJax-Span-588">
               t
              </span>
              <span class="mi" id="MathJax-Span-589">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        间的融合与
        <span class="MathJax" id="MathJax-Element-63-Frame">
         <span class="math" id="MathJax-Span-590">
          <span class="mrow" id="MathJax-Span-591">
           <span class="mi" id="MathJax-Span-592">
            L
           </span>
           <span class="msubsup" id="MathJax-Span-593">
            <span class="mi" id="MathJax-Span-594">
             N
            </span>
            <span class="texatom" id="MathJax-Span-595">
             <span class="mrow" id="MathJax-Span-596">
              <span class="mi" id="MathJax-Span-597">
               w
              </span>
              <span class="mi" id="MathJax-Span-598">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        间的融合类似，相应的算法也会减缓收敛（因为
        <span class="MathJax" id="MathJax-Element-64-Frame">
         <span class="math" id="MathJax-Span-599">
          <span class="mrow" id="MathJax-Span-600">
           <span class="msubsup" id="MathJax-Span-601">
            <span class="mi" id="MathJax-Span-602">
             N
            </span>
            <span class="texatom" id="MathJax-Span-603">
             <span class="mrow" id="MathJax-Span-604">
              <span class="mi" id="MathJax-Span-605">
               w
              </span>
              <span class="mi" id="MathJax-Span-606">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        是所有训练语料上的聚合结果，而
        <span class="MathJax" id="MathJax-Element-65-Frame">
         <span class="math" id="MathJax-Span-607">
          <span class="mrow" id="MathJax-Span-608">
           <span class="msubsup" id="MathJax-Span-609">
            <span class="mi" id="MathJax-Span-610">
             N
            </span>
            <span class="texatom" id="MathJax-Span-611">
             <span class="mrow" id="MathJax-Span-612">
              <span class="mi" id="MathJax-Span-613">
               t
              </span>
              <span class="mi" id="MathJax-Span-614">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        只和具体文档
        <em>
         d
        </em>
        有关，后者变化比前者更加“快速”，
        <span class="MathJax" id="MathJax-Element-66-Frame">
         <span class="math" id="MathJax-Span-615">
          <span class="mrow" id="MathJax-Span-616">
           <span class="msubsup" id="MathJax-Span-617">
            <span class="mi" id="MathJax-Span-618">
             N
            </span>
            <span class="texatom" id="MathJax-Span-619">
             <span class="mrow" id="MathJax-Span-620">
              <span class="mi" id="MathJax-Span-621">
               t
              </span>
              <span class="mi" id="MathJax-Span-622">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        的并行近似采样更加“危险”，很容易造成训练不收敛）。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f18.jpg"/>
        <br/>
        <strong>
         图18 模型并行1
        </strong>
       </div>
       <div>
       </div>
       <p>
        有没有办法不进行
        <span class="MathJax" id="MathJax-Element-67-Frame">
         <span class="math" id="MathJax-Span-623">
          <span class="mrow" id="MathJax-Span-624">
           <span class="msubsup" id="MathJax-Span-625">
            <span class="mi" id="MathJax-Span-626">
             N
            </span>
            <span class="texatom" id="MathJax-Span-627">
             <span class="mrow" id="MathJax-Span-628">
              <span class="mi" id="MathJax-Span-629">
               t
              </span>
              <span class="mi" id="MathJax-Span-630">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        的并行近似采样，同时保持上述的模型切片方式呢？Peacock系统设计了图19所示的并行采样方式：加载了不同
        <span class="MathJax" id="MathJax-Element-68-Frame">
         <span class="math" id="MathJax-Span-631">
          <span class="mrow" id="MathJax-Span-632">
           <span class="msubsup" id="MathJax-Span-633">
            <span class="mi" id="MathJax-Span-634">
             N
            </span>
            <span class="texatom" id="MathJax-Span-635">
             <span class="mrow" id="MathJax-Span-636">
              <span class="mo" id="MathJax-Span-637">
               (
              </span>
              <span class="mi" id="MathJax-Span-638">
               i
              </span>
              <span class="mo" id="MathJax-Span-639">
               )
              </span>
             </span>
            </span>
            <span class="texatom" id="MathJax-Span-640">
             <span class="mrow" id="MathJax-Span-641">
              <span class="mi" id="MathJax-Span-642">
               w
              </span>
              <span class="mi" id="MathJax-Span-643">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        切片的任务并行的沿对角线方向对训练语料数据块
        <em>
         (W,T)
        </em>
        进行采样，一条对角线采样完成后，依次进行下一条对角线。这样在对同一个文档的不同数据块间的词进行采样时，仍然保持了“串行性”，应用了之前数据块中的词对
        <span class="MathJax" id="MathJax-Element-69-Frame">
         <span class="math" id="MathJax-Span-644">
          <span class="mrow" id="MathJax-Span-645">
           <span class="msubsup" id="MathJax-Span-646">
            <span class="mi" id="MathJax-Span-647">
             N
            </span>
            <span class="texatom" id="MathJax-Span-648">
             <span class="mrow" id="MathJax-Span-649">
              <span class="mi" id="MathJax-Span-650">
               t
              </span>
              <span class="mi" id="MathJax-Span-651">
               d
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        的更新。图19的模型并行采样方式收敛性同AD-LDA是一致的。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f19.jpg"/>
        <br/>
        <strong>
         图19 模型并行2
        </strong>
       </div>
       <h4>
        3.3 大规模主题模型训练系统Peacock
       </h4>
       <p>
        为了“利用更多的数据训练更大的模型”，Peacock系统结合了上述的“数据并行”和“模型并行”（图20）：
       </p>
       <ul>
        <li>
         多组“模型并行”任务之间采用“数据并行”的方式工作，“模型并行”任务组内部，依然保持图19所示的并行采样方式；
        </li>
        <li>
         在迭代结束或任务处理训练语料数据块过程中，不同“模型并行”任务组之间或同步或异步的融合模型分片
         <span class="MathJax" id="MathJax-Element-70-Frame">
          <span class="math" id="MathJax-Span-652">
           <span class="mrow" id="MathJax-Span-653">
            <span class="mi" id="MathJax-Span-654">
             L
            </span>
            <span class="msubsup" id="MathJax-Span-655">
             <span class="mi" id="MathJax-Span-656">
              N
             </span>
             <span class="mi" id="MathJax-Span-657">
              i
             </span>
             <span class="texatom" id="MathJax-Span-658">
              <span class="mrow" id="MathJax-Span-659">
               <span class="mi" id="MathJax-Span-660">
                w
               </span>
               <span class="mi" id="MathJax-Span-661">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         。模型融合的方式可以类似MPI中的AllReduce，也可以借助全局的参数服务器
         <span class="MathJax" id="MathJax-Element-71-Frame">
          <span class="math" id="MathJax-Span-662">
           <span class="mrow" id="MathJax-Span-663">
            <span class="mi" id="MathJax-Span-664">
             G
            </span>
            <span class="msubsup" id="MathJax-Span-665">
             <span class="mi" id="MathJax-Span-666">
              N
             </span>
             <span class="mi" id="MathJax-Span-667">
              i
             </span>
             <span class="texatom" id="MathJax-Span-668">
              <span class="mrow" id="MathJax-Span-669">
               <span class="mi" id="MathJax-Span-670">
                w
               </span>
               <span class="mi" id="MathJax-Span-671">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         。
        </li>
       </ul>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f20.jpg"/>
        <br/>
        <strong>
         图20 Peacock中的数据并行和模型并行
        </strong>
       </div>
       <div>
       </div>
       <p>
        同上一小节“模型并行”的分析类似，Peacock系统的采样方式收敛性同AD-LDA是一致的。Max Welling团队提出的Async-LDA
        <sup>
         [6]
        </sup>
        证明了异步融合
        <span class="MathJax" id="MathJax-Element-72-Frame">
         <span class="math" id="MathJax-Span-672">
          <span class="mrow" id="MathJax-Span-673">
           <span class="mi" id="MathJax-Span-674">
            L
           </span>
           <span class="msubsup" id="MathJax-Span-675">
            <span class="mi" id="MathJax-Span-676">
             N
            </span>
            <span class="mi" id="MathJax-Span-677">
             i
            </span>
            <span class="texatom" id="MathJax-Span-678">
             <span class="mrow" id="MathJax-Span-679">
              <span class="mi" id="MathJax-Span-680">
               w
              </span>
              <span class="mi" id="MathJax-Span-681">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        方式的收敛性。当Peacock采用异步方式融合
        <span class="MathJax" id="MathJax-Element-73-Frame">
         <span class="math" id="MathJax-Span-682">
          <span class="mrow" id="MathJax-Span-683">
           <span class="mi" id="MathJax-Span-684">
            L
           </span>
           <span class="msubsup" id="MathJax-Span-685">
            <span class="mi" id="MathJax-Span-686">
             N
            </span>
            <span class="mi" id="MathJax-Span-687">
             i
            </span>
            <span class="texatom" id="MathJax-Span-688">
             <span class="mrow" id="MathJax-Span-689">
              <span class="mi" id="MathJax-Span-690">
               w
              </span>
              <span class="mi" id="MathJax-Span-691">
               t
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
        时，相当于同时结合了AD-LDA和Async-LDA算法，实践证明收敛性是没有问题的。
       </p>
       <p>
        当然，Peacock系统在具体实现上除了上述的主要设计思想，还有很多的实用技巧，比如：
       </p>
       <ul>
        <li>
         数据传输和文档采样之间的流水线。
        </li>
        <li>
         图19所示的模型并行方式在每条对角线并行采样结束后都需要同步，怎样去掉这种同步？
        </li>
        <li>
         怎样的模型
         <span class="MathJax" id="MathJax-Element-74-Frame">
          <span class="math" id="MathJax-Span-692">
           <span class="mrow" id="MathJax-Span-693">
            <span class="msubsup" id="MathJax-Span-694">
             <span class="mi" id="MathJax-Span-695">
              N
             </span>
             <span class="texatom" id="MathJax-Span-696">
              <span class="mrow" id="MathJax-Span-697">
               <span class="mi" id="MathJax-Span-698">
                w
               </span>
               <span class="mi" id="MathJax-Span-699">
                t
               </span>
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
         分片方式，能尽可能的保证采样服务器之间的负载均衡？
        </li>
        <li>
         我们是否需要每个迭代都重采样所有词的主题？
        </li>
        <li>
         怎样快速的计算对数似然度？
        </li>
        <li>
         怎样将模型的超参数
         <span class="MathJax" id="MathJax-Element-75-Frame">
          <span class="math" id="MathJax-Span-700">
           <span class="mrow" id="MathJax-Span-701">
            <span class="msubsup" id="MathJax-Span-702">
             <span class="mi" id="MathJax-Span-703">
              α
             </span>
             <span class="mi" id="MathJax-Span-704">
              t
             </span>
            </span>
           </span>
          </span>
         </span>
         和
         <span class="MathJax" id="MathJax-Element-76-Frame">
          <span class="math" id="MathJax-Span-705">
           <span class="mrow" id="MathJax-Span-706">
            <span class="mi" id="MathJax-Span-707">
             β
            </span>
           </span>
          </span>
         </span>
         优化融入Peacock系统？
        </li>
        <li>
         除了标准的吉布斯采样，是否有更加快速的采样算法？
        </li>
        <li>
         主题数
         <em>
          K
         </em>
         从100到1,000,000，系统的内部数据结构都保持不变么？
        </li>
       </ul>
       <p>
        在我们的论文
        <sup>
         [15]
        </sup>
        中，部分的解答了上述问题，更详细的Peacock解密请关注我们的博客“火光摇曳”
        <sup>
         [16]
        </sup>
        ^_^。
       </p>
       <h3>
        四、Peacock在腾讯都有哪些应用？
       </h3>
       <h4>
        4.1 文本语义分析
       </h4>
       <p>
        为了理解互联网上海量、多样化、非结构化的自然语言描述的文本，我们通常会从词法、句法、语义等维度进行分析。受限于文本字面信息量小，存在歧义现象，词法和句法分析容易遭遇 Vocabulary Gap的问题，从海量文本数据中归纳 “知识”，从语义角度帮助理解文本，是一种非常重要的途径。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f21.png"/>
        <br/>
        <strong>
         图21 文本分析示例
        </strong>
       </div>
       <div>
       </div>
       <p>
        例如，对于输入文本 “红酒木瓜汤效果怎么样？”，根据人的背景知识，很容易猜到这是一位女性用户在询问丰胸产品“红酒木瓜靓汤”的效果。对于机器而言，通常会先进行词法分析，对原始文本做切词、词性标注、命名实体识别等，然后使用词袋模型（Bag of Words，BOW）或提取关键词来表示文本。不难发现，从字面抽取的信息，很容易理解成“红酒”、“木瓜”等餐饮类语义，并非原始文本真实的意思。当然，我们可以对关键词做扩展，给出一些相似的词条，但是，更好的是直接理解语义。一种常见的方法是文本分类，由于对标注语料库的依赖，类别规模一般不会太大，粒度较粗。还有一种方法就是文本聚类，挖掘语义主题标签，更细粒度的理解文本意思，隐含语义分析技术逐渐发展成为常用的解决方案。能够从十亿级别的文档中归纳上百万语义的Peacock系统更是在腾讯广点通广告系统扮演着核心角色。这些不同维度的文本分析模块，包括词袋、关键词提取、关键词扩展、文本分类和Peacock等（图21），整合在一起构成了我们理解语言的基础文本分析平台TextMiner（图22）。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f22.jpg"/>
        <br/>
        <strong>
         图22 文本分析平台TextMiner
        </strong>
       </div>
       <h5>
        4.1.1 文本分类器
       </h5>
       <p>
        文本分类是一个典型的有监督的机器学习任务，我们在做在线广告系统过程中遇到的任务就有许多，包括网页分类、广告分类、QQ群分类、用户兴趣分类等。在使用相同的标注数据集和机器学习算法情况下，如何找到有区分力的特征无疑是最为关键的。
       </p>
       <p>
        以QQ群分类为例，使用群名称、群简介、群公告等文本描述，类别体系是二级层次结构，共100+节点，标注训练数据80,000。以BOW作为基础特征，新增Peacock主题特征后，一级行业准确率和召回率均有显著提升，达5%左右，二级行业在召回率降低不到1%的情况下，准确率提升达3.86%，达到了实际应用的需求。具体数据如图23所示。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f23.png"/>
        <br/>
        <strong>
         图23 QQ群分类器效果
        </strong>
       </div>
       <h5>
        4.1.2 相关性计算
       </h5>
       <p>
        对给定的查询语句，搜索引擎会将检索到的网页进行排序，把相关性好的排在前面。同样的，在线广告系统应该保证展示给用户的广告与页面内容、用户兴趣相关，以尽量不影响用户体验。这里都涉及到一个共同的任务：排序学习。此问题通常被形式化为有监督的学习问题，我们会将查询、网页、用户、广告表示成语义特征向量，从而在语义空间里比较用户意图（查询、网页内容、用户历史行为）和网页、广告的相关性。
       </p>
       <p>
        Peacock已成功应用在腾讯搜索广告和情境广告中，用于分析文本数据，归纳自然语言的语义，从而更好地匹配查询词和广告，以及页面内容和广告。在情境广告 Learning To Rank 相关性计算框架下，增加Peacock语义特征后，NDCG@5提升达8.92%，线上A/B Test实验 AdCTR 提升 8.82%。相关性评估效果图24所示。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f24.png"/>
       </div>
       <div>
        <strong>
         图24 情境广告相关性（相关性标注样本包括4,000 查询，200,000对(查询, 广告)，标注0~3四档打分）
        </strong>
       </div>
       <h4>
        4.2 广告CTR预估
       </h4>
       <p>
        广告点击率预估是预测给定场景下一个广告被点击的概率：P(click=1|ad,user,context)，user表示当前用户，context表示当前的环境信息，譬如当前所在的网页。点击率预估是在线广告系统最核心的技术之一，它决定着广告的排序和计价。
       </p>
       <p>
        业界一般做法是将广告展示、点击日志作为训练数据，抽取特征，通过机器学习方法拟合训练数据得到预估模型，进而做在线点击率预估。选取有效的特征对得到一个精准的点击率预估模型起着至关重要的作用。
       </p>
       <p>
        Peacock是我们理解广告语义的关键技术，被引入到广告点击率预估模型中提升效果。具体的，与KDD Cup 2012 Track2的数据集产生过程类似，我们使用了腾讯情境广告系统的广告展示、点击日志，使用L1范数正则的逻辑回归训练预估模型，通过AUC评估模型精度。Baseline使用一些基础特征，优化实验分别在baseline特征集合的基础上引入主题规模为1000、10,000和100,000的Peacock Top-N语义特征。
       </p>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f25.jpg"/>
        <br/>
        <strong>
         图25 pCTR增加不同粒度topic特征模型AUC的提升
        </strong>
       </div>
       <div>
       </div>
       <p>
        从图25可以看出，加入Peacock语义特征后AUC得到了显著提升，尤其当增加topic规模为100,000的Peacock语义特征时，AUC提升最大，约为1.8%，线上A/B Test实验AdCTR有8.82%的提升。
       </p>
       <h4>
        4.3 精准广告定向
       </h4>
       <p>
        在腾讯效果广告平台广点通系统里，Peacock被用于理解用户行为数据，从中归纳用户兴趣，提供广告精准定向技术。
       </p>
       <p>
        腾讯丰富的产品线拥有中国互联网公司最多的用户，有着海量、丰富的用户关系和行为数据，如QQ好友关系，QQ 群关系，电商浏览、交易，新闻浏览，查询 Query，UGC 内容（如微博、说说等），移动App 安装，微信公众号文章阅读和广告点击行为等。通过用户行为数据的挖掘可以帮助我们更好的了解用户，以推送精准的广告。而这些数据都可以形式化为用户-物品矩阵，如用户-用户、QQ-QQ群，用户-应用（Apps），用户-搜索词（或搜索Session），用户-URLs等。我们利用Peacock系统对上述用户-物品做矩阵分解（如图3），从不同数据来源，多视角理解用户兴趣，进而挖掘相似用户，提供给广告主丰富的定向策略，如用户商业兴趣定向、关键词定向和Look-Alike定向等。同时，获取到的用户特征，也可以作为广告CTR、CVR预估系统的重要特征。
       </p>
       <h4>
        4.4 QQ群推荐
       </h4>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f26.jpg"/>
        <br/>
        <strong>
         图26 QQ群推荐
        </strong>
       </div>
       <div>
       </div>
       <p>
        根据用户已加QQ群社交关系数据，利用Peacock对QQ-QQ群做矩阵分解，我们发现语义相近的QQ群被比较好的归到了相同的主题下，如图8、9、10所示。非常直观的，我们将Peacock 模型应用在QQ群消息面板推荐产品中（如图26），相比基于QQ好友关系链的推荐算法，推荐群的点击率和转化率（即点击后是否加入了该群）均有2~3倍的提升（图27）。
       </p>
       <div class="MathJax_Display">
        <span class="MathJax" id="MathJax-Element-77-Frame">
         <span class="math" id="MathJax-Span-708">
          <span class="mrow" id="MathJax-Span-709">
           <span class="mtable" id="MathJax-Span-710">
            <span class="mtd" id="MathJax-Span-714">
             <span class="mrow" id="MathJax-Span-715">
              <span class="mi" id="MathJax-Span-716">
               P
              </span>
              <span class="mo" id="MathJax-Span-717">
               (
              </span>
              <span class="mi" id="MathJax-Span-718">
               Q
              </span>
              <span class="mi" id="MathJax-Span-719">
               Q
              </span>
              <span class="mi" id="MathJax-Span-720">
               G
              </span>
              <span class="mi" id="MathJax-Span-721">
               r
              </span>
              <span class="mi" id="MathJax-Span-722">
               o
              </span>
              <span class="mi" id="MathJax-Span-723">
               u
              </span>
              <span class="mi" id="MathJax-Span-724">
               p
              </span>
              <span class="texatom" id="MathJax-Span-725">
               <span class="mrow" id="MathJax-Span-726">
                <span class="mo" id="MathJax-Span-727">
                 │
                </span>
               </span>
              </span>
              <span class="mi" id="MathJax-Span-728">
               u
              </span>
              <span class="mi" id="MathJax-Span-729">
               s
              </span>
              <span class="mi" id="MathJax-Span-730">
               e
              </span>
              <span class="mi" id="MathJax-Span-731">
               r
              </span>
              <span class="mo" id="MathJax-Span-732">
               )
              </span>
              <span class="mo" id="MathJax-Span-733">
               =
              </span>
              <span class="munderover" id="MathJax-Span-734">
               <span class="mo" id="MathJax-Span-735">
                ∑
               </span>
               <span class="texatom" id="MathJax-Span-736">
                <span class="mrow" id="MathJax-Span-737">
                 <span class="mi" id="MathJax-Span-738">
                  t
                 </span>
                 <span class="mi" id="MathJax-Span-739">
                  o
                 </span>
                 <span class="mi" id="MathJax-Span-740">
                  p
                 </span>
                 <span class="mi" id="MathJax-Span-741">
                  i
                 </span>
                 <span class="mi" id="MathJax-Span-742">
                  c
                 </span>
                </span>
               </span>
              </span>
              <span class="mi" id="MathJax-Span-743">
               P
              </span>
              <span class="mo" id="MathJax-Span-744">
               (
              </span>
              <span class="mi" id="MathJax-Span-745">
               Q
              </span>
              <span class="mi" id="MathJax-Span-746">
               Q
              </span>
              <span class="mi" id="MathJax-Span-747">
               G
              </span>
              <span class="mi" id="MathJax-Span-748">
               r
              </span>
              <span class="mi" id="MathJax-Span-749">
               o
              </span>
              <span class="mi" id="MathJax-Span-750">
               u
              </span>
              <span class="mi" id="MathJax-Span-751">
               p
              </span>
              <span class="texatom" id="MathJax-Span-752">
               <span class="mrow" id="MathJax-Span-753">
                <span class="mo" id="MathJax-Span-754">
                 |
                </span>
               </span>
              </span>
              <span class="mi" id="MathJax-Span-755">
               t
              </span>
              <span class="mi" id="MathJax-Span-756">
               o
              </span>
              <span class="mi" id="MathJax-Span-757">
               p
              </span>
              <span class="mi" id="MathJax-Span-758">
               i
              </span>
              <span class="mi" id="MathJax-Span-759">
               c
              </span>
              <span class="mo" id="MathJax-Span-760">
               )
              </span>
              <span class="mo" id="MathJax-Span-761">
               ⋅
              </span>
              <span class="mi" id="MathJax-Span-762">
               P
              </span>
              <span class="mo" id="MathJax-Span-763">
               (
              </span>
              <span class="mi" id="MathJax-Span-764">
               t
              </span>
              <span class="mi" id="MathJax-Span-765">
               o
              </span>
              <span class="mi" id="MathJax-Span-766">
               p
              </span>
              <span class="mi" id="MathJax-Span-767">
               i
              </span>
              <span class="mi" id="MathJax-Span-768">
               c
              </span>
              <span class="texatom" id="MathJax-Span-769">
               <span class="mrow" id="MathJax-Span-770">
                <span class="mo" id="MathJax-Span-771">
                 |
                </span>
               </span>
              </span>
              <span class="mi" id="MathJax-Span-772">
               u
              </span>
              <span class="mi" id="MathJax-Span-773">
               s
              </span>
              <span class="mi" id="MathJax-Span-774">
               e
              </span>
              <span class="mi" id="MathJax-Span-775">
               r
              </span>
              <span class="mo" id="MathJax-Span-776">
               )
              </span>
             </span>
            </span>
            <span class="mtd" id="mjx-eqn-eqresys">
             <span class="mrow" id="MathJax-Span-712">
              <span class="mtext" id="mjx-eqn-2">
               (2)
              </span>
             </span>
            </span>
           </span>
          </span>
         </span>
        </span>
       </div>
       <div>
        <img src="http://dataunion.org/wp-content/uploads/2015/03/p-f27.png"/>
        <br/>
        <strong>
         图27 QQ群推荐效果
        </strong>
       </div>
       <h3>
        后记
       </h3>
       <p>
        LDA是一个简洁、优雅、实用的隐含主题模型，腾讯效果广告平台部（广点通）的工程师们为了应对互联网的大数据处理，开发了大规模隐含主题模型建模系统，并在腾讯的多个业务数据中得到了应用。本文由赵学敏、王莉峰、王流斌执笔，靳志辉、孙振龙等修订，相关工作由腾讯SNG效果广告平台部（广点通）质量研发中心Peacock团队王益、赵学敏、孙振龙、严浩、王莉峰、靳志辉、王流斌为主完成，苏州大学曾嘉教授、实习生高阳，香港科技大学杨强教授等持续大力支持，是多人合作的结果。
       </p>
       <h3>
        参考文献
       </h3>
       <ul>
        <li>
         [1] Greg Linden, Brent Smith, and Jeremy York.
         <em>
          Amazon.com Recommendations: Item-to-Item Collaborative Filtering
         </em>
         . IEEE Internet Computing, 2003.
        </li>
        <li>
         [2] Simon Funk.
         <em>
          Netflix Update: Try This at Home
         </em>
         .
         <a href="http://sifter.org/~simon/journal/20061211.html">
          http://sifter.org/~simon/journal/20061211.html
         </a>
         .
        </li>
        <li>
         [3]
         <em>
          分布式机器学习的故事
         </em>
         .
         <a href="http://cxwangyi.github.io/2014/01/20/distributed-machine-learning/">
          http://cxwangyi.github.io/2014/01/20/distributed-machine-learning/
         </a>
         .
        </li>
        <li>
         [4]
         <em>
          LinkedIn
         </em>
         <em>
          高级分析师王益:
         </em>
         <em>
          大数据时代的理想主义和现实主义(
         </em>
         <em>
          图灵访谈).
         </em>
         <a href="http://www.ituring.com.cn/article/75445">
          http://www.ituring.com.cn/article/75445
         </a>
         .
        </li>
        <li>
         [5]
         <em>
          PLDA and PLDA+
         </em>
         .
         <a href="https://code.google.com/p/plda/">
          https://code.google.com/p/plda/
         </a>
         .
        </li>
        <li>
         [6] Arthur Asuncion, Padhraic Smyth, and MaxWelling.
         <em>
          Asynchronous Distributed Learning of Topic Models
         </em>
         . NIPS’2008.
        </li>
        <li>
         [7]
         <em>
          Yahoo_LDA
         </em>
         .
         <a href="https://github.com/shravanmn/Yahoo_LDA">
          https://github.com/shravanmn/Yahoo_LDA
         </a>
         .
        </li>
        <li>
         [8]
         <em>
          MALLET.
         </em>
         <a href="http://mallet.cs.umass.edu/">
          http://mallet.cs.umass.edu/
         </a>
         .
        </li>
        <li>
         [9] Mark Steyvers, and Tom Griffiths.
         <em>
          Probabilistic topic models
         </em>
         . In T. Landauer, D McNamara, S. Dennis, and W. Kintsch (eds), Latent Semantic Analysis: A Road to Meaning. Laurence Erlbaum, 2006.
        </li>
        <li>
         [10] D. Blei, A. Ng, and M. Jordan.
         <em>
          Latent Dirichlet allocation.
         </em>
         JMLR’2003.
        </li>
        <li>
         [11] Thomas L. Griffiths, and Mark Steyvers.
         <em>
          Finding scientific topics.
         </em>
         PNAS’2004.
        </li>
        <li>
         [12] Gregor Heinrich.
         <em>
          Parameter estimation for text analysis.
         </em>
         Technical Report, 2009.
        </li>
        <li>
         [13] Jeffrey Dean, Greg S. Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Quoc V. Le, Mark Z. Mao, Marc’Aurelio Ranzato, Andrew Senior, Paul Tucker, Ke Yang, Andrew Y. Ng.
         <em>
          Large Scale Distributed Deep Networks.
         </em>
         NIPS’2012.
        </li>
        <li>
         [14] David Newman, Arthur Asuncion, Padhraic Smyth, and MaxWelling.
         <em>
          Distributed Algorithms for Topic Models.
         </em>
         JMLR’2009.
        </li>
        <li>
         [15] Yi Wang, Xuemin Zhao, Zhenlong Sun, Hao Yan, Lifeng Wang, Zhihui Jin, Liubin Wang, Yang Gao, Ching Law, and Jia Zeng.
         <em>
          Peacock: Learning Long-Tail Topic Features for Industrial Applications.
         </em>
         TIST’2015.
        </li>
        <li>
         [16]
         <em>
          火光摇曳.
         </em>
         <a href="http://www.flickering.cn/">
          http://www.flickering.cn/
         </a>
         .
        </li>
       </ul>
       <div>
       </div>
       <div>
       </div>
       <div>
       </div>
       <div id="myCopyRight">
        <p>
         本文链接：
         <a href="http://www.flickering.cn/nlp/2015/03/peacock%ef%bc%9a%e5%a4%a7%e8%a7%84%e6%a8%a1%e4%b8%bb%e9%a2%98%e6%a8%a1%e5%9e%8b%e5%8f%8a%e5%85%b6%e5%9c%a8%e8%85%be%e8%ae%af%e4%b8%9a%e5%8a%a1%e4%b8%ad%e7%9a%84%e5%ba%94%e7%94%a8/" rel="bookmark" title="本文固定链接 http://www.flickering.cn/nlp/2015/03/peacock%ef%bc%9a%e5%a4%a7%e8%a7%84%e6%a8%a1%e4%b8%bb%e9%a2%98%e6%a8%a1%e5%9e%8b%e5%8f%8a%e5%85%b6%e5%9c%a8%e8%85%be%e8%ae%af%e4%b8%9a%e5%8a%a1%e4%b8%ad%e7%9a%84%e5%ba%94%e7%94%a8/">
          Peacock：大规模主题模型及其在腾讯业务中的应用
         </a>
         <br/>
         来源：
         <a href="http://www.flickering.cn/">
          火光摇曳
         </a>
        </p>
       </div>
      </div>
      <div>
       <strong>
        注：转载文章均来自于公开网络，仅供学习使用，不会用于任何商业用途，如果侵犯到原作者的权益，请您与我们联系删除或者授权事宜，联系邮箱：contact@dataunion.org。转载数盟网站文章请注明原文章作者，否则产生的任何版权纠纷与数盟无关。
       </strong>
      </div>
      <!--content_text-->
      <div class="fenxian">
       <!-- JiaThis Button BEGIN -->
       <div class="jiathis_style_32x32">
        <p class="jiathis_button_weixin">
        </p>
        <p class="jiathis_button_tsina">
        </p>
        <p class="jiathis_button_qzone">
        </p>
        <p class="jiathis_button_cqq">
        </p>
        <p class="jiathis_button_tumblr">
        </p>
        <a class="jiathis jiathis_txt jtico jtico_jiathis" href="http://www.jiathis.com/share" target="_blank">
        </a>
        <p class="jiathis_counter_style">
        </p>
       </div>
       <!-- JiaThis Button END -->
      </div>
     </article>
     <!--content-->
     <!--相关文章-->
     <div class="xianguan">
      <div class="xianguantitle">
       相关文章！
      </div>
      <ul class="pic">
       <li>
        <a href="http://dataunion.org/20758.html">
         <img src="http://dataunion.org/wp-content/uploads/2015/09/t012aec1078cd96f01f-300x199.jpg"/>
        </a>
        <a class="link" href="http://dataunion.org/20758.html" rel="bookmark" title="推荐一些从零开始学习机器学习算法的方法">
         推荐一些从零开始学习机器学习算法的方法
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/20714.html">
         <img src="http://dataunion.org/wp-content/uploads/2015/09/t011650727f6392a3f5-300x197.jpg"/>
        </a>
        <a class="link" href="http://dataunion.org/20714.html" rel="bookmark" title="寻找最优参数解：最速下降法，牛顿下降法，阻尼牛顿法，拟牛顿法DFP/BFGS">
         寻找最优参数解：最速下降法，牛顿下降法，阻尼牛顿法，拟牛顿法DFP/BFGS
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/20636.html">
         <img src="http://dataunion.org/wp-content/uploads/2015/09/t01034a6a3b660f0c04_副本-300x203.jpg"/>
        </a>
        <a class="link" href="http://dataunion.org/20636.html" rel="bookmark" title="机器学习开发者的现代化攻略：对统计学微积分Say NO！">
         机器学习开发者的现代化攻略：对统计学微积分Say NO！
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/20632.html">
         <img src="http://dataunion.org/wp-content/uploads/2015/08/t01e4f9fea2b69f4b1f-300x189.jpg"/>
        </a>
        <a class="link" href="http://dataunion.org/20632.html" rel="bookmark" title="机器学习到底适合哪些人群学习？">
         机器学习到底适合哪些人群学习？
        </a>
       </li>
      </ul>
     </div>
     <!--相关文章-->
     <div class="comment" id="comments">
      <!-- You can start editing here. -->
      <!-- If comments are open, but there are no comments. -->
      <div class="title">
       期待你一针见血的评论，Come on！
      </div>
      <div id="respond">
       <p>
        不用想啦，马上
        <a href="http://dataunion.org/wp-login.php?redirect_to=http%3A%2F%2Fdataunion.org%2F11407.html">
         "登录"
        </a>
        发表自已的想法.
       </p>
      </div>
     </div>
     <!-- .nav-single -->
    </div>
    <!--Container End-->
    <aside id="sitebar">
     <div class="sitebar_list2">
      <div class="wptag">
       <span class="tagtitle">
        热门标签+
       </span>
       <div class="tagg">
        <ul class="menu" id="menu-%e5%8f%8b%e6%83%85%e9%93%be%e6%8e%a5">
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-1605" id="menu-item-1605">
          <a href="http://taidizh.com/">
           泰迪智慧
          </a>
         </li>
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-20884" id="menu-item-20884">
          <a href="http://www.transwarp.cn/">
           星环科技
          </a>
         </li>
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3538" id="menu-item-3538">
          <a href="http://datall.org/">
           珈和遥感
          </a>
         </li>
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-20888" id="menu-item-20888">
          <a href="http://www.chinahadoop.cn/">
           小象学院
          </a>
         </li>
        </ul>
       </div>
      </div>
     </div>
     <div class="sitebar_list">
      <div class="textwidget">
       <div align="center">
        <a href="http://study.163.com/course/courseMain.htm?courseId=991022" target="_blank">
         <img src="http://dataunion.org/wp-content/uploads/2016/03/dv.jpg"/>
        </a>
       </div>
      </div>
     </div>
     <div class="sitebar_list">
      <h4 class="sitebar_title">
       文章分类
      </h4>
      <div class="tagcloud">
       <a class="tag-link-44" href="http://dataunion.org/category/industry/demo" style="font-size: 10.204724409449pt;" title="4个话题">
        Demo展示
       </a>
       <a class="tag-link-31" href="http://dataunion.org/category/experts" style="font-size: 15.826771653543pt;" title="52个话题">
        专家团队
       </a>
       <a class="tag-link-870" href="http://dataunion.org/category/tech/ai" style="font-size: 19.795275590551pt;" title="273个话题">
        人工智能
       </a>
       <a class="tag-link-488" href="http://dataunion.org/category/%e5%8a%a0%e5%85%a5%e6%95%b0%e7%9b%9f" style="font-size: 8pt;" title="1个话题">
        加入数盟
       </a>
       <a class="tag-link-869" href="http://dataunion.org/category/tech/viz" style="font-size: 17.204724409449pt;" title="93个话题">
        可视化
       </a>
       <a class="tag-link-30" href="http://dataunion.org/category/partners" style="font-size: 10.645669291339pt;" title="5个话题">
        合作伙伴
       </a>
       <a class="tag-link-889" href="http://dataunion.org/category/parterc" style="font-size: 11.582677165354pt;" title="8个话题">
        合作会议
       </a>
       <a class="tag-link-104" href="http://dataunion.org/category/books" style="font-size: 12.96062992126pt;" title="15个话题">
        图书
       </a>
       <a class="tag-link-220" href="http://dataunion.org/category/tech/base" style="font-size: 19.850393700787pt;" title="281个话题">
        基础架构
       </a>
       <a class="tag-link-219" href="http://dataunion.org/category/tech/analysis" style="font-size: 19.409448818898pt;" title="232个话题">
        数据分析
       </a>
       <a class="tag-link-887" href="http://dataunion.org/category/tech/dm" style="font-size: 13.291338582677pt;" title="17个话题">
        数据挖掘
       </a>
       <a class="tag-link-34" href="http://dataunion.org/category/tech" style="font-size: 20.732283464567pt;" title="404个话题">
        文章
       </a>
       <a class="tag-link-1" href="http://dataunion.org/category/uncategorized" style="font-size: 22pt;" title="693个话题">
        未分类
       </a>
       <a class="tag-link-4" href="http://dataunion.org/category/events" style="font-size: 14.503937007874pt;" title="29个话题">
        活动
       </a>
       <a class="tag-link-890" href="http://dataunion.org/category/tech/%e6%b7%b1%e5%ba%a6%e5%ad%a6%e4%b9%a0" style="font-size: 10.204724409449pt;" title="4个话题">
        深度学习
       </a>
       <a class="tag-link-221" href="http://dataunion.org/category/tech/devl" style="font-size: 18.968503937008pt;" title="193个话题">
        编程语言
       </a>
       <a class="tag-link-888" href="http://dataunion.org/category/career" style="font-size: 15.661417322835pt;" title="48个话题">
        职业规划
       </a>
       <a class="tag-link-5" href="http://dataunion.org/category/jobs" style="font-size: 14.11811023622pt;" title="25个话题">
        职位
       </a>
       <a class="tag-link-871" href="http://dataunion.org/category/industry" style="font-size: 15.716535433071pt;" title="49个话题">
        行业
       </a>
       <a class="tag-link-613" href="http://dataunion.org/category/industry/case" style="font-size: 16.984251968504pt;" title="84个话题">
        行业应用
       </a>
       <a class="tag-link-885" href="http://dataunion.org/category/industry/news" style="font-size: 17.425196850394pt;" title="102个话题">
        行业资讯
       </a>
       <a class="tag-link-10" href="http://dataunion.org/category/training" style="font-size: 14.228346456693pt;" title="26个话题">
        课程
       </a>
       <a class="tag-link-16" href="http://dataunion.org/category/sources" style="font-size: 15.661417322835pt;" title="48个话题">
        资源
       </a>
      </div>
     </div>
     <div class="sitebar_list">
      <h4 class="sitebar_title">
       功能
      </h4>
      <ul>
       <li>
        <a href="http://dataunion.org/wp-login.php?action=register">
         注册
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/wp-login.php">
         登录
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/feed">
         文章
         <abbr title="Really Simple Syndication">
          RSS
         </abbr>
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/comments/feed">
         评论
         <abbr title="Really Simple Syndication">
          RSS
         </abbr>
        </a>
       </li>
       <li>
        <a href="https://cn.wordpress.org/" title="基于WordPress，一个优美、先进的个人信息发布平台。">
         WordPress.org
        </a>
       </li>
      </ul>
     </div>
    </aside>
    <div class="clear">
    </div>
   </div>
   <!--main-->
   ﻿
   <footer id="dibu">
    <div class="about">
     <div class="right">
      <ul class="menu" id="menu-%e5%ba%95%e9%83%a8%e8%8f%9c%e5%8d%95">
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-18024" id="menu-item-18024">
        <a href="http://dataunion.org/category/partners">
         合作伙伴
        </a>
       </li>
       <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-20881" id="menu-item-20881">
        <a href="http://dataunion.org/contribute">
         文章投稿
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-20872" id="menu-item-20872">
        <a href="http://dataunion.org/category/%e5%8a%a0%e5%85%a5%e6%95%b0%e7%9b%9f">
         加入数盟
        </a>
       </li>
       <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-22441" id="menu-item-22441">
        <a href="http://dataunion.org/f-links">
         友情链接
        </a>
       </li>
       <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-20874" id="menu-item-20874">
        <a href="http://dataunion.org/aboutus">
         关于数盟
        </a>
       </li>
      </ul>
      <p class="banquan">
       数盟社区        ，
        做最棒的数据科学社区
      </p>
     </div>
     <div class="left">
      <ul class="bottomlist">
       <li>
        <a href="http://weibo.com/DataScientistUnion  " target="_blank" 　title="">
         <img src="http://dataunion.org/wp-content/themes/yzipi/images/weibo.png"/>
        </a>
       </li>
       <li>
        <a class="cd-popup-trigger" href="http://dataunion.org/11407.html#0">
         <img src="http://dataunion.org/wp-content/themes/yzipi/images/weixin.png"/>
        </a>
       </li>
      </ul>
      <div class="cd-popup">
       <div class="cd-popup-container">
        <h1>
         扫描二维码,加微信公众号
        </h1>
        <img src="http://dataunion.org/wp-content/themes/yzipi/images/2014-12-06-1515289049.png"/>
        <a class="cd-popup-close" href="http://dataunion.org/11407.html">
        </a>
       </div>
       <!-- cd-popup-container -->
      </div>
      <!-- cd-popup -->
     </div>
    </div>
    <!--about-->
    <div class="bottom">
     <a href="http://dataunion.org/">
      数盟社区
     </a>
     <a href="http://www.miitbeian.gov.cn/" rel="external nofollow" target="_blank">
      京ICP备14026740号
     </a>
     联系我们：
     <a href="mailto:contact@dataunion.org" target="_blank">
      contact@dataunion.org
     </a>
     <div class="tongji">
     </div>
     <!--bottom-->
     <div class="scroll" id="scroll" style="display:none;">
      ︿
     </div>
    </div>
   </footer>
   <!--dibu-->
  </div>
 </body>
</html>